SPI 初始化结构体

  1. typedef struct
  2. {
  3.     uint16_t SPI_Direction;             /*设置 SPI 的单双向模式 */
  4.     uint16_t SPI_Mode;                 /*设置 SPI 的主/从机端模式 */
  5.     uint16_t SPI_DataSize;             /*设置 SPI 的数据帧长度，可选 8/16 位 */
  6.     uint16_t SPI_CPOL;                 /*设置时钟极性 CPOL，可选高/低电平*/
  7.     uint16_t SPI_CPHA;                 /*设置时钟相位，可选奇/偶数边沿采样 */
  8.     uint16_t SPI_NSS;                 /*设置 NSS 引脚由 SPI 硬件控制还是软件控制*/
  9.     uint16_t SPI_BaudRatePrescaler; /*设置时钟分频因子， fpclk/分频数=fSCK */
  10.     uint16_t SPI_FirstBit;             /*设置 MSB/LSB 先行 */
  11.     uint16_t SPI_CRCPolynomial;         /*设置 CRC 校验的表达式 */
  12. } SPI_InitTypeDef;

SPI读写FLASH实例

bsp_spi_flash.h

  1. #ifndef __SPI_FLASH_H
  2. #define __SPI_FLASH_H
  4. #include "stm32f10x.h"
  5. #include <stdio.h>
  7. //#define  sFLASH_ID              0xEF3015   //W25X16
  8. //#define  sFLASH_ID              0xEF4015     //W25Q16
  9. //#define  sFLASH_ID              0XEF4018   //W25Q128
  10. #define  sFLASH_ID              0XEF4017    //W25Q64
  12. #define SPI_FLASH_PageSize              256
  13. #define SPI_FLASH_PerWritePageSize      256
  15. /*命令定义-开头*******************************/
  16. #define W25X_WriteEnable              0x06 
  17. #define W25X_WriteDisable              0x04 
  18. #define W25X_ReadStatusReg            0x05 
  19. #define W25X_WriteStatusReg            0x01 
  20. #define W25X_ReadData                    0x03 
  21. #define W25X_FastReadData              0x0B 
  22. #define W25X_FastReadDual              0x3B 
  23. #define W25X_PageProgram              0x02 
  24. #define W25X_BlockErase                  0xD8 
  25. #define W25X_SectorErase              0x20 
  26. #define W25X_ChipErase                  0xC7 
  27. #define W25X_PowerDown                  0xB9 
  28. #define W25X_ReleasePowerDown        0xAB 
  29. #define W25X_DeviceID                    0xAB 
  30. #define W25X_ManufactDeviceID       0x90 
  31. #define W25X_JedecDeviceID            0x9F
  33. /* WIP(busy)标志，FLASH内部正在写入 */
  34. #define WIP_Flag                  0x01
  35. #define Dummy_Byte                0xFF
  36. /*命令定义-结尾*******************************/
  39. /*SPI接口定义-开头****************************/
  40. #define      FLASH_SPIx                        SPI1
  41. #define      FLASH_SPI_APBxClock_FUN          RCC_APB2PeriphClockCmd
  42. #define      FLASH_SPI_CLK                     RCC_APB2Periph_SPI1
  44. //CS(NSS)引脚 片选选普通GPIO即可
  45. #define      FLASH_SPI_CS_APBxClock_FUN       RCC_APB2PeriphClockCmd
  46. #define      FLASH_SPI_CS_CLK                  RCC_APB2Periph_GPIOA    
  47. #define      FLASH_SPI_CS_PORT                 GPIOA
  48. #define      FLASH_SPI_CS_PIN                  GPIO_Pin_4
  50. //SCK引脚
  51. #define      FLASH_SPI_SCK_APBxClock_FUN      RCC_APB2PeriphClockCmd
  52. #define      FLASH_SPI_SCK_CLK                 RCC_APB2Periph_GPIOA   
  53. #define      FLASH_SPI_SCK_PORT                GPIOA   
  54. #define      FLASH_SPI_SCK_PIN                 GPIO_Pin_5
  55. //MISO引脚
  56. #define      FLASH_SPI_MISO_APBxClock_FUN     RCC_APB2PeriphClockCmd
  57. #define      FLASH_SPI_MISO_CLK                RCC_APB2Periph_GPIOA    
  58. #define      FLASH_SPI_MISO_PORT               GPIOA 
  59. #define      FLASH_SPI_MISO_PIN                GPIO_Pin_6
  60. //MOSI引脚
  61. #define      FLASH_SPI_MOSI_APBxClock_FUN     RCC_APB2PeriphClockCmd
  62. #define      FLASH_SPI_MOSI_CLK                RCC_APB2Periph_GPIOA    
  63. #define      FLASH_SPI_MOSI_PORT               GPIOA 
  64. #define      FLASH_SPI_MOSI_PIN                GPIO_Pin_7
  66. #define          SPI_FLASH_CS_LOW()                             GPIO_ResetBits( FLASH_SPI_CS_PORT, FLASH_SPI_CS_PIN )
  67. #define          SPI_FLASH_CS_HIGH()                            GPIO_SetBits( FLASH_SPI_CS_PORT, FLASH_SPI_CS_PIN )
  69. /*SPI接口定义-结尾****************************/
  71. /*等待超时时间*/
  72. #define SPIT_FLAG_TIMEOUT         ((uint32_t)0x1000)
  73. #define SPIT_LONG_TIMEOUT         ((uint32_t)(10 * SPIT_FLAG_TIMEOUT))
  75. /*信息输出*/
  76. #define FLASH_DEBUG_ON         1
  78. #define FLASH_INFO(fmt,arg...)           printf("<<-FLASH-INFO->> "fmt"\n",##arg)
  79. #define FLASH_ERROR(fmt,arg...)          printf("<<-FLASH-ERROR->> "fmt"\n",##arg)
  80. #define FLASH_DEBUG(fmt,arg...)          do{\
  81.                                           if(FLASH_DEBUG_ON)\
  82.                                           printf("<<-FLASH-DEBUG->> [%d]"fmt"\n",__LINE__, ##arg);\
  83.                                           }while(0)
  85. void SPI_FLASH_Init(void);
  86. void SPI_FLASH_SectorErase(u32 SectorAddr);
  87. void SPI_FLASH_BulkErase(void);
  88. void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite);
  89. void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite);
  90. void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead);
  91. u32 SPI_FLASH_ReadID(void);
  92. u32 SPI_FLASH_ReadDeviceID(void);
  93. void SPI_FLASH_StartReadSequence(u32 ReadAddr);
  94. void SPI_Flash_PowerDown(void);
  95. void SPI_Flash_WAKEUP(void);
  98. u8 SPI_FLASH_ReadByte(void);
  99. u8 SPI_FLASH_SendByte(u8 byte);
  100. u16 SPI_FLASH_SendHalfWord(u16 HalfWord);
  101. void SPI_FLASH_WriteEnable(void);
  102. void SPI_FLASH_WaitForWriteEnd(void);
  105. #endif /* __SPI_FLASH_H */

bsp_spi_flash.c

  1.  /**
  2.   ******************************************************************************
  3.   * @file    bsp_xxx.c
  4.   * @author  STMicroelectronics
  5.   * @version V1.0
  6.   * @date    2013-xx-xx
  7.   * @brief   spi flash 底层应用函数bsp 
  8.   ******************************************************************************
  9.   * @attention
  10.   *
  11.   * 实验平台:野火 F103-霸道 STM32 开发板 
  12.   * 论坛    :http://www.firebbs.cn
  13.   * 淘宝    :https://fire-stm32.taobao.com
  14.   *
  15.   ******************************************************************************
  16.   */
  18. #include "./flash/bsp_spi_flash.h"
  20. static __IO uint32_t  SPITimeout = SPIT_LONG_TIMEOUT;    
  21. static uint16_t SPI_TIMEOUT_UserCallback(uint8_t errorCode);
  23. /**
  24.   * @brief  SPI_FLASH初始化
  25.   * @param  无
  26.   * @retval 无
  27.   */
  28. void SPI_FLASH_Init(void)
  29. {
  30.   SPI_InitTypeDef  SPI_InitStructure;
  31.   GPIO_InitTypeDef GPIO_InitStructure;
  33.   /* 使能SPI时钟 */
  34.   FLASH_SPI_APBxClock_FUN ( FLASH_SPI_CLK, ENABLE );
  36.   /* 使能SPI引脚相关的时钟 */  // cs sck miso mosi引脚都是在GPIOA上，所以只需使能1个就行
  37.   FLASH_SPI_CS_APBxClock_FUN( FLASH_SPI_CS_CLK, ENABLE );
  38.   //FLASH_SPI_CS_APBxClock_FUN( FLASH_SPI_CS_CLK | FLASH_SPI_SCK_CLK, ENABLE );                                                            FLASH_SPI_MISO_PIN|FLASH_SPI_MOSI_PIN, ENABLE );
  40.   /* 配置SPI的 CS引脚，普通IO即可 */
  41.   GPIO_InitStructure.GPIO_Pin = FLASH_SPI_CS_PIN;
  42.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  43.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  44.   GPIO_Init(FLASH_SPI_CS_PORT, &GPIO_InitStructure);
  46.   /* 配置SPI的 SCK引脚*/
  47.   GPIO_InitStructure.GPIO_Pin = FLASH_SPI_SCK_PIN;
  48.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  49.   GPIO_Init(FLASH_SPI_SCK_PORT, &GPIO_InitStructure);
  51.   /* 配置SPI的 MISO引脚*/
  52.   GPIO_InitStructure.GPIO_Pin = FLASH_SPI_MISO_PIN;
  53.   GPIO_Init(FLASH_SPI_MISO_PORT, &GPIO_InitStructure);
  55.   /* 配置SPI的 MOSI引脚*/
  56.   GPIO_InitStructure.GPIO_Pin = FLASH_SPI_MOSI_PIN;
  57.   GPIO_Init(FLASH_SPI_MOSI_PORT, &GPIO_InitStructure);
  59.   /* 停止信号 FLASH: CS引脚高电平*/
  60.   SPI_FLASH_CS_HIGH();
  62.   /* SPI 模式配置 */
  63.   // FLASH芯片 支持SPI模式0及模式3，据此设置CPOL CPHA
  64.   SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  65.   SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  66.   SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  67.   SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
  68.   SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
  69.   SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  70.   SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
  71.   SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  72.   SPI_InitStructure.SPI_CRCPolynomial = 7;
  73.   SPI_Init(FLASH_SPIx , &SPI_InitStructure);
  75.   /* 使能 SPI  */
  76.   SPI_Cmd(FLASH_SPIx , ENABLE);
  78. }
  79.  /**
  80.   * @brief  擦除FLASH扇区
  81.   * @param  SectorAddr：要擦除的扇区地址
  82.   * @retval 无
  83.   */
  84. void SPI_FLASH_SectorErase(u32 SectorAddr)
  85. {
  86.   /* 发送FLASH写使能命令 */
  87.   SPI_FLASH_WriteEnable();
  88.   SPI_FLASH_WaitForWriteEnd();
  89.   /* 擦除扇区 */
  90.   /* 选择FLASH: CS低电平 */
  91.   SPI_FLASH_CS_LOW();
  92.   /* 发送扇区擦除指令*/
  93.   SPI_FLASH_SendByte(W25X_SectorErase);
  94.   /*发送擦除扇区地址的高位*/
  95.   SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
  96.   /* 发送擦除扇区地址的中位 */
  97.   SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
  98.   /* 发送擦除扇区地址的低位 */
  99.   SPI_FLASH_SendByte(SectorAddr & 0xFF);
  100.   /* 停止信号 FLASH: CS 高电平 */
  101.   SPI_FLASH_CS_HIGH();
  102.   /* 等待擦除完毕*/
  103.   SPI_FLASH_WaitForWriteEnd();
  104. }
  106.  /**
  107.   * @brief  擦除FLASH扇区，整片擦除
  108.   * @param  无
  109.   * @retval 无
  110.   */
  111. void SPI_FLASH_BulkErase(void)
  112. {
  113.   /* 发送FLASH写使能命令 */
  114.   SPI_FLASH_WriteEnable();
  116.   /* 整块 Erase */
  117.   /* 选择FLASH: CS低电平 */
  118.   SPI_FLASH_CS_LOW();
  119.   /* 发送整块擦除指令*/
  120.   SPI_FLASH_SendByte(W25X_ChipErase);
  121.   /* 停止信号 FLASH: CS 高电平 */
  122.   SPI_FLASH_CS_HIGH();
  124.   /* 等待擦除完毕*/
  125.   SPI_FLASH_WaitForWriteEnd();
  126. }
  128.  /**
  129.   * @brief  对FLASH按页写入数据，调用本函数写入数据前需要先擦除扇区
  130.   * @param    pBuffer，要写入数据的指针
  131.   * @param WriteAddr，写入地址
  132.   * @param  NumByteToWrite，写入数据长度，必须小于等于SPI_FLASH_PerWritePageSize
  133.   * @retval 无
  134.   */
  135. void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
  136. {
  137.   /* 发送FLASH写使能命令 */
  138.   SPI_FLASH_WriteEnable();
  140.   /* 选择FLASH: CS低电平 */
  141.   SPI_FLASH_CS_LOW();
  142.   /* 写页写指令*/
  143.   SPI_FLASH_SendByte(W25X_PageProgram);
  144.   /*发送写地址的高位*/
  145.   SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
  146.   /*发送写地址的中位*/
  147.   SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
  148.   /*发送写地址的低位*/
  149.   SPI_FLASH_SendByte(WriteAddr & 0xFF);
  151.   if(NumByteToWrite > SPI_FLASH_PerWritePageSize)
  152.   {
  153.      NumByteToWrite = SPI_FLASH_PerWritePageSize;
  154.      FLASH_ERROR("SPI_FLASH_PageWrite too large!"); 
  155.   }
  157.   /* 写入数据*/
  158.   while (NumByteToWrite--)
  159.   {
  160.     /* 发送当前要写入的字节数据 */
  161.     SPI_FLASH_SendByte(*pBuffer);
  162.     /* 指向下一字节数据 */
  163.     pBuffer++;
  164.   }
  166.   /* 停止信号 FLASH: CS 高电平 */
  167.   SPI_FLASH_CS_HIGH();
  169.   /* 等待写入完毕*/
  170.   SPI_FLASH_WaitForWriteEnd();
  171. }
  173.  /**
  174.   * @brief  对FLASH写入数据，调用本函数写入数据前需要先擦除扇区
  175.   * @param    pBuffer，要写入数据的指针
  176.   * @param  WriteAddr，写入地址
  177.   * @param  NumByteToWrite，写入数据长度
  178.   * @retval 无
  179.   */
  180. void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
  181. {
  182.   u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
  184.   /*mod运算求余，若writeAddr是SPI_FLASH_PageSize整数倍，运算结果Addr值为0*/
  185.   Addr = WriteAddr % SPI_FLASH_PageSize;
  187.   /*差count个数据值，刚好可以对齐到页地址*/
  188.   count = SPI_FLASH_PageSize - Addr;
  189.   /*计算出要写多少整数页*/
  190.   NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
  191.   /*mod运算求余，计算出剩余不满一页的字节数*/
  192.   NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
  194.   /* Addr=0,则WriteAddr 刚好按页对齐 aligned  */
  195.   if (Addr == 0)
  196.   {
  197.     /* NumByteToWrite < SPI_FLASH_PageSize */
  198.     if (NumOfPage == 0) 
  199.     {
  200.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
  201.     }
  202.     else /* NumByteToWrite > SPI_FLASH_PageSize */
  203.     { 
  204.       /*先把整数页都写了*/
  205.       while (NumOfPage--)
  206.       {
  207.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
  208.         WriteAddr +=  SPI_FLASH_PageSize;
  209.         pBuffer += SPI_FLASH_PageSize;
  210.       }
  211.       /*若有多余的不满一页的数据，把它写完*/
  212.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
  213.     }
  214.   }
  215.     /* 若地址与 SPI_FLASH_PageSize 不对齐  */
  216.   else 
  217.   {
  218.         /* NumByteToWrite < SPI_FLASH_PageSize */
  219.     if (NumOfPage == 0)
  220.     {
  221.         /*当前页剩余的count个位置比NumOfSingle小，一页写不完*/
  222.       if (NumOfSingle > count) 
  223.       {
  224.         temp = NumOfSingle - count;
  225.         /*先写满当前页*/
  226.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
  228.         WriteAddr +=  count;
  229.         pBuffer += count;
  230.         /*再写剩余的数据*/
  231.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
  232.       }
  233.       else /*当前页剩余的count个位置能写完NumOfSingle个数据*/
  234.       {
  235.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
  236.       }
  237.     }
  238.     else /* NumByteToWrite > SPI_FLASH_PageSize */
  239.     {
  240.         /*地址不对齐多出的count分开处理，不加入这个运算*/
  241.       NumByteToWrite -= count;
  242.       NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
  243.       NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
  245.         /* 先写完count个数据，为的是让下一次要写的地址对齐 */
  246.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
  248.         /* 接下来就重复地址对齐的情况 */
  249.       WriteAddr +=  count;
  250.       pBuffer += count;
  251.         /*把整数页都写了*/
  252.       while (NumOfPage--)
  253.       {
  254.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
  255.         WriteAddr +=  SPI_FLASH_PageSize;
  256.         pBuffer += SPI_FLASH_PageSize;
  257.       }
  258.         /*若有多余的不满一页的数据，把它写完*/
  259.       if (NumOfSingle != 0)
  260.       {
  261.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
  262.       }
  263.     }
  264.   }
  265. }
  267.  /**
  268.   * @brief  读取FLASH数据
  269.   * @param     pBuffer，存储读出数据的指针
  270.   * @param   ReadAddr，读取地址
  271.   * @param   NumByteToRead，读取数据长度
  272.   * @retval 无
  273.   */
  274. void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead)
  275. {
  276.   /* 选择FLASH: CS低电平 */
  277.   SPI_FLASH_CS_LOW();
  279.   /* 发送 读 指令 */
  280.   SPI_FLASH_SendByte(W25X_ReadData);
  282.   /* 发送 读 地址高位 */
  283.   SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
  284.   /* 发送 读 地址中位 */
  285.   SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
  286.   /* 发送 读 地址低位 */
  287.   SPI_FLASH_SendByte(ReadAddr & 0xFF);
  289.     /* 读取数据 */
  290.   while (NumByteToRead--) /* while there is data to be read */
  291.   {
  292.     /* 读取一个字节*/
  293.     *pBuffer = SPI_FLASH_SendByte(Dummy_Byte);
  294.     /* 指向下一个字节缓冲区 */
  295.     pBuffer++;
  296.   }
  298.   /* 停止信号 FLASH: CS 高电平 */
  299.   SPI_FLASH_CS_HIGH();
  300. }
  302.  /**
  303.   * @brief  读取FLASH ID
  304.   * @param     无
  305.   * @retval FLASH ID
  306.   */
  307. u32 SPI_FLASH_ReadID(void)
  308. {
  309.   u32 Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;
  311.   /* 开始通讯：CS低电平 */
  312.   SPI_FLASH_CS_LOW();
  314.   /* 发送JEDEC指令，读取ID */
  315.   SPI_FLASH_SendByte(W25X_JedecDeviceID);
  317.   /* 读取一个字节数据 */
  318.   Temp0 = SPI_FLASH_SendByte(Dummy_Byte);
  320.   /* 读取一个字节数据 */
  321.   Temp1 = SPI_FLASH_SendByte(Dummy_Byte);
  323.   /* 读取一个字节数据 */
  324.   Temp2 = SPI_FLASH_SendByte(Dummy_Byte);
  326.  /* 停止通讯：CS高电平 */
  327.   SPI_FLASH_CS_HIGH();
  329.   /*把数据组合起来，作为函数的返回值*/
  330.     Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;
  332.   return Temp;
  333. }
  334.  /**
  335.   * @brief  读取FLASH Device ID
  336.   * @param     无
  337.   * @retval FLASH Device ID
  338.   */
  339. u32 SPI_FLASH_ReadDeviceID(void)
  340. {
  341.   u32 Temp = 0;
  343.   /* Select the FLASH: Chip Select low */
  344.   SPI_FLASH_CS_LOW();
  346.   /* Send "RDID " instruction */
  347.   SPI_FLASH_SendByte(W25X_DeviceID);
  348.   SPI_FLASH_SendByte(Dummy_Byte);
  349.   SPI_FLASH_SendByte(Dummy_Byte);
  350.   SPI_FLASH_SendByte(Dummy_Byte);
  352.   /* Read a byte from the FLASH */
  353.   Temp = SPI_FLASH_SendByte(Dummy_Byte);
  355.   /* Deselect the FLASH: Chip Select high */
  356.   SPI_FLASH_CS_HIGH();
  358.   return Temp;
  359. }
  360. /*******************************************************************************
  361. * Function Name  : SPI_FLASH_StartReadSequence
  362. * Description    : Initiates a read data byte (READ) sequence from the Flash.
  363. *                  This is done by driving the /CS line low to select the device,
  364. *                  then the READ instruction is transmitted followed by 3 bytes
  365. *                  address. This function exit and keep the /CS line low, so the
  366. *                  Flash still being selected. With this technique the whole
  367. *                  content of the Flash is read with a single READ instruction.
  368. * Input          : - ReadAddr : FLASH's internal address to read from.
  369. * Output         : None
  370. * Return         : None
  371. *******************************************************************************/
  372. void SPI_FLASH_StartReadSequence(u32 ReadAddr)
  373. {
  374.   /* Select the FLASH: Chip Select low */
  375.   SPI_FLASH_CS_LOW();
  377.   /* Send "Read from Memory " instruction */
  378.   SPI_FLASH_SendByte(W25X_ReadData);
  380.   /* Send the 24-bit address of the address to read from -----------------------*/
  381.   /* Send ReadAddr high nibble address byte */
  382.   SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
  383.   /* Send ReadAddr medium nibble address byte */
  384.   SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
  385.   /* Send ReadAddr low nibble address byte */
  386.   SPI_FLASH_SendByte(ReadAddr & 0xFF);
  387. }
  390.  /**
  391.   * @brief  使用SPI读取一个字节的数据
  392.   * @param  无
  393.   * @retval 返回接收到的数据
  394.   */
  395. u8 SPI_FLASH_ReadByte(void)
  396. {
  397.   return (SPI_FLASH_SendByte(Dummy_Byte));
  398. }
  400.  /**
  401.   * @brief  使用SPI发送一个字节的数据
  402.   * @param  byte：要发送的数据
  403.   * @retval 返回接收到的数据
  404.   */
  405. u8 SPI_FLASH_SendByte(u8 byte)
  406. {
  407.      SPITimeout = SPIT_FLAG_TIMEOUT;
  408.   /* 等待发送缓冲区为空，TXE事件 */
  409.   while (SPI_I2S_GetFlagStatus(FLASH_SPIx , SPI_I2S_FLAG_TXE) == RESET)
  410.     {
  411.     if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(0);
  412.    }
  414.   /* 写入数据寄存器，把要写入的数据写入发送缓冲区 */
  415.   SPI_I2S_SendData(FLASH_SPIx , byte);
  417.     SPITimeout = SPIT_FLAG_TIMEOUT;
  418.   /* 等待接收缓冲区非空，RXNE事件 */
  419.   while (SPI_I2S_GetFlagStatus(FLASH_SPIx , SPI_I2S_FLAG_RXNE) == RESET)
  420.   {
  421.     if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(1);
  422.    }
  424.   /* 读取数据寄存器，获取接收缓冲区数据 */
  425.   return SPI_I2S_ReceiveData(FLASH_SPIx );
  426. }
  428.  /**
  429.   * @brief  使用SPI发送两个字节的数据
  430.   * @param  byte：要发送的数据
  431.   * @retval 返回接收到的数据
  432.   */
  433. u16 SPI_FLASH_SendHalfWord(u16 HalfWord)
  434. {
  435.       SPITimeout = SPIT_FLAG_TIMEOUT;
  436.   /* 等待发送缓冲区为空，TXE事件 */
  437.   while (SPI_I2S_GetFlagStatus(FLASH_SPIx , SPI_I2S_FLAG_TXE) == RESET)
  438.     {
  439.     if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(2);
  440.    }
  442.   /* 写入数据寄存器，把要写入的数据写入发送缓冲区 */
  443.   SPI_I2S_SendData(FLASH_SPIx , HalfWord);
  445.      SPITimeout = SPIT_FLAG_TIMEOUT;
  446.   /* 等待接收缓冲区非空，RXNE事件 */
  447.   while (SPI_I2S_GetFlagStatus(FLASH_SPIx , SPI_I2S_FLAG_RXNE) == RESET)
  448.      {
  449.     if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(3);
  450.    }
  451.   /* 读取数据寄存器，获取接收缓冲区数据 */
  452.   return SPI_I2S_ReceiveData(FLASH_SPIx );
  453. }
  455.  /**
  456.   * @brief  向FLASH发送 写使能 命令
  457.   * @param  none
  458.   * @retval none
  459.   */
  460. void SPI_FLASH_WriteEnable(void)
  461. {
  462.   /* 通讯开始：CS低 */
  463.   SPI_FLASH_CS_LOW();
  465.   /* 发送写使能命令*/
  466.   SPI_FLASH_SendByte(W25X_WriteEnable);
  468.   /*通讯结束：CS高 */
  469.   SPI_FLASH_CS_HIGH();
  470. }
  472. /* WIP(busy)标志，FLASH内部正在写入 */
  473. #define WIP_Flag                  0x01
  475.  /**
  476.   * @brief  等待WIP(BUSY)标志被置0，即等待到FLASH内部数据写入完毕
  477.   * @param  none
  478.   * @retval none
  479.   */
  480. void SPI_FLASH_WaitForWriteEnd(void)
  481. {
  482.   u8 FLASH_Status = 0;
  484.   /* 选择 FLASH: CS 低 */
  485.   SPI_FLASH_CS_LOW();
  487.   /* 发送 读状态寄存器 命令 */
  488.   SPI_FLASH_SendByte(W25X_ReadStatusReg);
  490.   /* 若FLASH忙碌，则等待 */
  491.   do
  492.   {
  493.         /* 读取FLASH芯片的状态寄存器 */
  494.     FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte);     
  495.   }
  496.   while ((FLASH_Status & WIP_Flag) == SET);  /* 正在写入标志 */
  498.   /* 停止信号  FLASH: CS 高 */
  499.   SPI_FLASH_CS_HIGH();
  500. }
  503. //进入掉电模式
  504. void SPI_Flash_PowerDown(void)   
  505. { 
  506.   /* 通讯开始：CS低 */
  507.   SPI_FLASH_CS_LOW();
  509.   /* 发送 掉电 命令 */
  510.   SPI_FLASH_SendByte(W25X_PowerDown);
  512.   /*通讯结束：CS高 */
  513.   SPI_FLASH_CS_HIGH();
  514. }   
  516. //唤醒
  517. void SPI_Flash_WAKEUP(void)   
  518. {
  519.   /*选择 FLASH: CS 低 */
  520.   SPI_FLASH_CS_LOW();
  522.   /* 发送 上电 命令 */
  523.   SPI_FLASH_SendByte(W25X_ReleasePowerDown);
  525.    /* 停止信号 FLASH: CS 高 */
  526.   SPI_FLASH_CS_HIGH();
  527. }   
  530. /**
  531.   * @brief  等待超时回调函数
  532.   * @param  None.
  533.   * @retval None.
  534.   */
  535. static  uint16_t SPI_TIMEOUT_UserCallback(uint8_t errorCode)
  536. {
  537.   /* 等待超时后的处理,输出错误信息 */
  538.   FLASH_ERROR("SPI 等待超时!errorCode = %d",errorCode);
  539.   return 0;
  540. }
  542. /*********************************************END OF FILE**********************/

main.c

 /**
  ******************************************************************************
  * @file    main.c
  * @author  fire
  * @version V1.0
  * @date    2013-xx-xx
  * @brief   华邦 8M串行flash测试，并将测试信息通过串口1在电脑的超级终端中打印出来
  ******************************************************************************
  * @attention
  *
  * 实验平台:野火 F103-霸道 STM32 开发板 
  * 论坛    :http://www.firebbs.cn
  * 淘宝    :https://fire-stm32.taobao.com
  *
  ******************************************************************************
  */ 
#include "stm32f10x.h"
#include "./usart/bsp_usart.h"
#include "./led/bsp_led.h"
#include "./flash/bsp_spi_flash.h"


typedef enum { FAILED = 0, PASSED = !FAILED} TestStatus;

/* 获取缓冲区的长度 */
#define TxBufferSize1   (countof(TxBuffer1) - 1)
#define RxBufferSize1   (countof(TxBuffer1) - 1)
#define countof(a)      (sizeof(a) / sizeof(*(a)))
#define  BufferSize (countof(Tx_Buffer)-1)

#define  FLASH_WriteAddress     0x00000
#define  FLASH_ReadAddress      FLASH_WriteAddress
#define  FLASH_SectorToErase    FLASH_WriteAddress



/* 发送缓冲区初始化 */
uint8_t Tx_Buffer[] = "感谢您选用野火stm32开发板\r\n";
uint8_t Rx_Buffer[BufferSize];

__IO uint32_t DeviceID = 0;
__IO uint32_t FlashID = 0;
__IO TestStatus TransferStatus1 = FAILED;

// 函数原型声明
void Delay(__IO uint32_t nCount);
TestStatus Buffercmp(uint8_t* pBuffer1,uint8_t* pBuffer2, uint16_t BufferLength);

/*
 * 函数名：main
 * 描述  ：主函数
 * 输入  ：无
 * 输出  ：无
 */
int main(void)
{     
    LED_GPIO_Config();
    LED_BLUE;

    /* 配置串口为：115200 8-N-1 */
    USART_Config();
    printf("\r\n 这是一个8Mbyte串行flash(W25Q64)实验 \r\n");

    /* 8M串行flash W25Q64初始化 */
    SPI_FLASH_Init();

    /* 获取 Flash Device ID */
    DeviceID = SPI_FLASH_ReadDeviceID();    
    Delay( 200 );

    /* 获取 SPI Flash ID */
    FlashID = SPI_FLASH_ReadID();    
    printf("\r\n FlashID is 0x%X,\
    Manufacturer Device ID is 0x%X\r\n", FlashID, DeviceID);

    /* 检验 SPI Flash ID */
    if (FlashID == sFLASH_ID)
    {    
        printf("\r\n 检测到串行flash W25Q64 !\r\n");

        /* 擦除将要写入的 SPI FLASH 扇区，FLASH写入前要先擦除 */
        // 这里擦除4K，即一个扇区，擦除的最小单位是扇区
        SPI_FLASH_SectorErase(FLASH_SectorToErase);          

        /* 将发送缓冲区的数据写到flash中 */
        // 这里写一页，一页的大小为256个字节
        SPI_FLASH_BufferWrite(Tx_Buffer, FLASH_WriteAddress, BufferSize);        
        printf("\r\n 写入的数据为：%s \r\t", Tx_Buffer);

        /* 将刚刚写入的数据读出来放到接收缓冲区中 */
        SPI_FLASH_BufferRead(Rx_Buffer, FLASH_ReadAddress, BufferSize);
        printf("\r\n 读出的数据为：%s \r\n", Rx_Buffer);

        /* 检查写入的数据与读出的数据是否相等 */
        TransferStatus1 = Buffercmp(Tx_Buffer, Rx_Buffer, BufferSize);

        if( PASSED == TransferStatus1 )
        { 
            LED_GREEN;
            printf("\r\n 8M串行flash(W25Q64)测试成功!\n\r");
        }
        else
        {        
            LED_RED;
            printf("\r\n 8M串行flash(W25Q64)测试失败!\n\r");
        }
    }// if (FlashID == sFLASH_ID)
    else// if (FlashID == sFLASH_ID)
    { 
        LED_RED;
        printf("\r\n 获取不到 W25Q64 ID!\n\r");
    }

    while(1);  
}

/*
 * 函数名：Buffercmp
 * 描述  ：比较两个缓冲区中的数据是否相等
 * 输入  ：-pBuffer1     src缓冲区指针
 *         -pBuffer2     dst缓冲区指针
 *         -BufferLength 缓冲区长度
 * 输出  ：无
 * 返回  ：-PASSED pBuffer1 等于   pBuffer2
 *         -FAILED pBuffer1 不同于 pBuffer2
 */
TestStatus Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength)
{
  while(BufferLength--)
  {
    if(*pBuffer1 != *pBuffer2)
    {
      return FAILED;
    }

    pBuffer1++;
    pBuffer2++;
  }
  return PASSED;
}

void Delay(__IO uint32_t nCount)
{
  for(; nCount != 0; nCount--);
}
/*********************************************END OF FILE**********************/

程序文件1-W25Q64.zip

W25Q64存储小数和整数

2-W25Q64存储小数和整数.zip