最近浏览的板块
搜索
返回列表 发新帖我要提问

[RISC-V MCU 应用开发] 【RISC-V MCU CH32V103测评】W25Q16 Flash存储器 Raw数据读写

[复制链接]
254|2
大头哥
 楼主 | 2020-12-3 22:07 | 显示全部楼层 |阅读模式
参考了不少前辈的例程，实践了一下。

测试效果如图所示：


主要更改3个源码文件，2个SPI Flash访问驱动，1个main函数，全部列在此处。
Hardware/spiflash.c
  1. /*****************************************
  2. *@Note
  3. Winbond W25Qxx SPIFLASH
  4. pins:
  5. CS   —— PA2
  6. DO   —— PA6(SPI1_MISO)
  7. WP   —— 3.3V
  8. DI   —— PA7(SPI1_MOSI)
  9. CLK  —— PA5(SPI1_SCK)
  10. HOLD —— 3.3V
  11. *******************************************/
  12. #include "debug.h"
  13. #include "string.h"
  14. #include "spiflash.h"

  16. /* Global define */

  18. /* Global Variable */
  19. u8 SPI_FLASH_BUF[4096];

  21. /*******************************************************************************
  22. * Function Name  : SPI1_ReadWriteByte
  23. * Description    : SPI1 read or write one byte.
  24. * Input          : TxData: write one byte data.
  25. * Return         : Read one byte data.
  26. *******************************************************************************/
  27. u8 SPI1_ReadWriteByte(u8 TxData)
  28. {
  29.     u8 i = 0;

  31.     while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET)
  32.     {
  33.         i++;
  34.         if (i > 200)
  35.             return 0;
  36.     }

  38.     SPI_I2S_SendData(SPI1, TxData);
  39.     i = 0;

  41.     while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET)
  42.     {
  43.         i++;
  44.         if (i > 200)
  45.             return 0;
  46.     }

  48.     return SPI_I2S_ReceiveData(SPI1);
  49. }

  51. /*******************************************************************************
  52. * Function Name  : SPI_Flash_Init
  53. * Description    : Configuring the SPI for operation flash.
  54. * Input          : None
  55. * Return         : None
  56. *******************************************************************************/
  57. void SPI_Flash_Init(void)
  58. {
  59.     GPIO_InitTypeDef GPIO_InitStructure;
  60.     SPI_InitTypeDef SPI_InitStructure;

  62.     RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA | RCC_APB2Periph_SPI1, ENABLE);

  64.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
  65.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  66.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  67.     GPIO_Init(GPIOA, &GPIO_InitStructure);
  68.     GPIO_SetBits(GPIOA, GPIO_Pin_2);

  70.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
  71.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  72.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  73.     GPIO_Init( GPIOA, &GPIO_InitStructure);

  75.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
  76.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  77.     GPIO_Init( GPIOA, &GPIO_InitStructure);

  79.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
  80.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  81.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  82.     GPIO_Init( GPIOA, &GPIO_InitStructure);

  84.     SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  85.     SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  86.     SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  87.     SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
  88.     SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
  89.     SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  90.     SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
  91.     SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  92.     SPI_InitStructure.SPI_CRCPolynomial = 7;
  93.     SPI_Init(SPI1, &SPI_InitStructure);

  95.     SPI_Cmd(SPI1, ENABLE);
  96. }

  98. /*******************************************************************************
  99. * Function Name  : SPI_Flash_ReadSR
  100. * Description    : Read W25Qxx status register.
  101. *       ——BIT7  6   5   4   3   2   1   0
  102. *       ——SPR   RV  TB  BP2 BP1 BP0 WEL BUSY
  103. * Input          : None
  104. * Return         : byte: status register value.
  105. *******************************************************************************/
  106. u8 SPI_Flash_ReadSR(void)
  107. {
  108.     u8 byte = 0;

  110.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
  111.     SPI1_ReadWriteByte(W25X_ReadStatusReg);
  112.     byte = SPI1_ReadWriteByte(0Xff);
  113.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);

  115.     return byte;
  116. }

  118. /*******************************************************************************
  119. * Function Name  : SPI_FLASH_Write_SR
  120. * Description    : Write W25Qxx status register.
  121. * Input          : sr:status register value.
  122. * Return         : None
  123. *******************************************************************************/
  124. void SPI_FLASH_Write_SR(u8 sr)
  125. {
  126.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
  127.     SPI1_ReadWriteByte(W25X_WriteStatusReg);
  128.     SPI1_ReadWriteByte(sr);
  129.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
  130. }

  132. /*******************************************************************************
  133. * Function Name  : SPI_Flash_Wait_Busy
  134. * Description    : Wait flash free.
  135. * Input          : None
  136. * Return         : None
  137. *******************************************************************************/
  138. void SPI_Flash_Wait_Busy(void)
  139. {
  140.     while ((SPI_Flash_ReadSR() & 0x01) == 0x01)
  141.         ;
  142. }

  144. /*******************************************************************************
  145. * Function Name  : SPI_FLASH_Write_Enable
  146. * Description    : Enable flash write.
  147. * Input          : None
  148. * Return         : None
  149. *******************************************************************************/
  150. void SPI_FLASH_Write_Enable(void)
  151. {
  152.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
  153.     SPI1_ReadWriteByte(W25X_WriteEnable);
  154.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
  155. }

  157. /*******************************************************************************
  158. * Function Name  : SPI_FLASH_Write_Disable
  159. * Description    : Disable flash write.
  160. * Input          : None
  161. * Return         : None
  162. *******************************************************************************/
  163. void SPI_FLASH_Write_Disable(void)
  164. {
  165.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
  166.     SPI1_ReadWriteByte(W25X_WriteDisable);
  167.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
  168. }

  170. /*******************************************************************************
  171. * Function Name  : SPI_Flash_ReadID
  172. * Description    : Read flash ID.
  173. * Input          : None
  174. * Return         : Temp: FLASH ID.
  175. *******************************************************************************/
  176. u16 SPI_Flash_ReadID(void)
  177. {
  178.     u16 Temp = 0;

  180.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
  181.     SPI1_ReadWriteByte(W25X_ManufactDeviceID);
  182.     SPI1_ReadWriteByte(0x00);
  183.     SPI1_ReadWriteByte(0x00);
  184.     SPI1_ReadWriteByte(0x00);
  185.     Temp |= SPI1_ReadWriteByte(0xFF) << 8;
  186.     Temp |= SPI1_ReadWriteByte(0xFF);
  187.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);

  189.     return Temp;
  190. }

  192. /*******************************************************************************
  193. * Function Name  : SPI_Flash_Erase_Sector
  194. * Description    : Erase one sector(4Kbyte).
  195. * Input          : Dst_Addr:  0 —— 2047
  196. * Return         : None
  197. *******************************************************************************/
  198. void SPI_Flash_Erase_Sector(u32 Dst_Addr)
  199. {
  200.     Dst_Addr *= 4096;
  201.     SPI_FLASH_Write_Enable();
  202.     SPI_Flash_Wait_Busy();
  203.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
  204.     SPI1_ReadWriteByte(W25X_SectorErase);
  205.     SPI1_ReadWriteByte((u8) ((Dst_Addr) >> 16));
  206.     SPI1_ReadWriteByte((u8) ((Dst_Addr) >> 8));
  207.     SPI1_ReadWriteByte((u8) Dst_Addr);
  208.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
  209.     SPI_Flash_Wait_Busy();
  210. }

  212. /*******************************************************************************
  213. * Function Name  : SPI_Flash_Read
  214. * Description    : Read data from flash.
  215. * Input          : pBuffer:
  216. *                  ReadAddr:Initial address(24bit).
  217. *                  size: Data length.
  218. * Return         : None
  219. *******************************************************************************/
  220. void SPI_Flash_Read(u8* pBuffer, u32 ReadAddr, u16 size)
  221. {
  222.     u16 i;

  224.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
  225.     SPI1_ReadWriteByte(W25X_ReadData);
  226.     SPI1_ReadWriteByte((u8) ((ReadAddr) >> 16));
  227.     SPI1_ReadWriteByte((u8) ((ReadAddr) >> 8));
  228.     SPI1_ReadWriteByte((u8) ReadAddr);

  230.     for (i = 0; i < size; i++)
  231.     {
  232.         pBuffer[i] = SPI1_ReadWriteByte(0XFF);
  233.     }

  235.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
  236. }

  238. /*******************************************************************************
  239. * Function Name  : SPI_Flash_Write_Page
  240. * Description    : Write data by one page.
  241. * Input          : pBuffer:
  242. *                  WriteAddr:Initial address(24bit).
  243. *                  size:Data length.
  244. * Return         : None
  245. *******************************************************************************/
  246. void SPI_Flash_Write_Page(u8* pBuffer, u32 WriteAddr, u16 size)
  247. {
  248.     u16 i;

  250.     SPI_FLASH_Write_Enable();
  251.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
  252.     SPI1_ReadWriteByte(W25X_PageProgram);
  253.     SPI1_ReadWriteByte((u8) ((WriteAddr) >> 16));
  254.     SPI1_ReadWriteByte((u8) ((WriteAddr) >> 8));
  255.     SPI1_ReadWriteByte((u8) WriteAddr);

  257.     for (i = 0; i < size; i++)
  258.     {
  259.         SPI1_ReadWriteByte(pBuffer[i]);
  260.     }

  262.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
  263.     SPI_Flash_Wait_Busy();
  264. }

  266. /*******************************************************************************
  267. * Function Name  : SPI_Flash_Write_NoCheck
  268. * Description    : Write data to flash.(need Erase)
  269. *                  All data in address rang is 0xFF.
  270. * Input          : pBuffer:
  271. *                  WriteAddr: Initial address(24bit).
  272. *                  size: Data length.
  273. * Return         : None
  274. *******************************************************************************/
  275. void SPI_Flash_Write_NoCheck(u8* pBuffer, u32 WriteAddr, u16 size)
  276. {
  277.     u16 pageremain;

  279.     pageremain = 256 - WriteAddr % 256;

  281.     if (size <= pageremain)
  282.         pageremain = size;

  284.     while (1)
  285.     {
  286.         SPI_Flash_Write_Page(pBuffer, WriteAddr, pageremain);

  288.         if (size == pageremain)
  289.         {
  290.             break;
  291.         }
  292.         else
  293.         {
  294.             pBuffer += pageremain;
  295.             WriteAddr += pageremain;
  296.             size -= pageremain;

  298.             if (size > 256)
  299.                 pageremain = 256;
  300.             else
  301.                 pageremain = size;
  302.         }
  303.     }
  304. }

  306. /*******************************************************************************
  307. * Function Name  : SPI_Flash_Write
  308. * Description    : Write data to flash.(no need Erase)
  309. * Input          : pBuffer:
  310. *                  WriteAddr: Initial address(24bit).
  311. *                  size: Data length.
  312. * Return         : None
  313. *******************************************************************************/
  314. void SPI_Flash_Write(u8* pBuffer, u32 WriteAddr, u16 size)
  315. {
  316.     u32 secpos;
  317.     u16 secoff;
  318.     u16 secremain;
  319.     u16 i;

  321.     secpos = WriteAddr / 4096;
  322.     secoff = WriteAddr % 4096;
  323.     secremain = 4096 - secoff;

  325.     if (size <= secremain)
  326.         secremain = size;

  328.     while (1)
  329.     {
  330.         SPI_Flash_Read(SPI_FLASH_BUF, secpos * 4096, 4096);

  332.         for (i = 0; i < secremain; i++)
  333.         {
  334.             if (SPI_FLASH_BUF[secoff + i] != 0XFF)
  335.                 break;
  336.         }

  338.         if (i < secremain)
  339.         {
  340.             SPI_Flash_Erase_Sector(secpos);

  342.             for (i = 0; i < secremain; i++)
  343.             {
  344.                 SPI_FLASH_BUF[i + secoff] = pBuffer[i];
  345.             }

  347.             SPI_Flash_Write_NoCheck(SPI_FLASH_BUF, secpos * 4096, 4096);

  349.         }
  350.         else
  351.         {
  352.             SPI_Flash_Write_NoCheck(pBuffer, WriteAddr, secremain);
  353.         }

  355.         if (size == secremain)
  356.         {
  357.             break;
  358.         }
  359.         else
  360.         {
  361.             secpos++;
  362.             secoff = 0;

  364.             pBuffer += secremain;
  365.             WriteAddr += secremain;
  366.             size -= secremain;

  368.             if (size > 4096)
  369.             {
  370.                 secremain = 4096;
  371.             }
  372.             else
  373.             {
  374.                 secremain = size;
  375.             }
  376.         }
  377.     }
  378. }

  380. /*******************************************************************************
  381. * Function Name  : SPI_Flash_Erase_Chip
  382. * Description    : Erase all FLASH pages.
  383. * Input          : None
  384. * Return         : None
  385. *******************************************************************************/
  386. void SPI_Flash_Erase_Chip(void)
  387. {
  388.     SPI_FLASH_Write_Enable();
  389.     SPI_Flash_Wait_Busy();
  390.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
  391.     SPI1_ReadWriteByte(W25X_ChipErase);
  392.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
  393.     SPI_Flash_Wait_Busy();
  394. }

  396. /*******************************************************************************
  397. * Function Name  : SPI_Flash_PowerDown
  398. * Description    : Enter power down mode.
  399. * Input          : None
  400. * Return         : None
  401. *******************************************************************************/
  402. void SPI_Flash_PowerDown(void)
  403. {
  404.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
  405.     SPI1_ReadWriteByte(W25X_PowerDown);
  406.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
  407.     Delay_Us(3);
  408. }

  410. /*******************************************************************************
  411. * Function Name  : SPI_Flash_WAKEUP
  412. * Description    : Power down wake up.
  413. * Input          : None
  414. * Return         : None
  415. *******************************************************************************/
  416. void SPI_Flash_WAKEUP(void)
  417. {
  418.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
  419.     SPI1_ReadWriteByte(W25X_ReleasePowerDown);
  420.     GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
  421.     Delay_Us(3);
  422. }
复制代码


Hardware/spiflash.h
  1. #ifndef __SPIFLASH_H
  2. #define __SPIFLASH_H


  5. /* Winbond SPIFalsh ID */
  6. #define W25Q80  0XEF13
  7. #define W25Q16  0XEF14
  8. #define W25Q32  0XEF15
  9. #define W25Q64  0XEF16
  10. #define W25Q128 0XEF17

  12. /* Winbond SPIFalsh Instruction List */
  13. #define W25X_WriteEnable            0x06
  14. #define W25X_WriteDisable           0x04
  15. #define W25X_ReadStatusReg          0x05
  16. #define W25X_WriteStatusReg         0x01
  17. #define W25X_ReadData               0x03
  18. #define W25X_FastReadData           0x0B
  19. #define W25X_FastReadDual           0x3B
  20. #define W25X_PageProgram            0x02
  21. #define W25X_BlockErase             0xD8
  22. #define W25X_SectorErase            0x20
  23. #define W25X_ChipErase              0xC7
  24. #define W25X_PowerDown              0xB9
  25. #define W25X_ReleasePowerDown       0xAB
  26. #define W25X_DeviceID               0xAB
  27. #define W25X_ManufactDeviceID       0x90
  28. #define W25X_JedecDeviceID          0x9F

  30. u8 SPI1_ReadWriteByte(u8 TxData);
  31. void SPI_Flash_Init(void);
  32. u8 SPI_Flash_ReadSR(void);
  33. void SPI_FLASH_Write_SR(u8 sr);
  34. void SPI_Flash_Wait_Busy(void);
  35. void SPI_FLASH_Write_Enable(void);
  36. void SPI_FLASH_Write_Disable(void);
  37. u16 SPI_Flash_ReadID(void);
  38. void SPI_Flash_Erase_Sector(u32 Dst_Addr);
  39. void SPI_Flash_Read(u8* pBuffer,u32 ReadAddr,u16 size);
  40. void SPI_Flash_Write_Page(u8* pBuffer,u32 WriteAddr,u16 size);
  41. void SPI_Flash_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 size);
  42. void SPI_Flash_Write(u8* pBuffer,u32 WriteAddr,u16 size);
  43. void SPI_Flash_Erase_Chip(void);
  44. void SPI_Flash_PowerDown(void);
  45. void SPI_Flash_WAKEUP(void);

  47. #endif

复制代码


main.c
  1. /********************************** (C) COPYRIGHT *******************************
  2. * File Name          : main.c
  3. * Author             : WCH
  4. * Version            : V1.0.0
  5. * Date               : 2020/04/30
  6. * Description        : Main program body.
  7. *******************************************************************************/

  9. /*
  10. *@Note
  11. W25Q16串行 Flash存储器 Raw数据读写测试例程。
  12. */

  14. #pragma message("short-cut R11 before programming")

  16. #include <string.h>
  17. #include "debug.h"
  18. #include "../Hardware/spiflash.h"

  20. /* Global typedef */

  22. /* Global define */

  24. /* Global Variable */
  25. const u8 TEXT_Buf[] =
  26. { "CH32F103C8T6 SPI FLASH W25Qxx Read/Write raw data buffer content" };

  28. #define SIZE sizeof(TEXT_Buf)

  30. /*******************************************************************************
  31. * Function Name  : main
  32. * Description    : Main program.
  33. * Input          : None
  34. * Return         : None
  35. *******************************************************************************/
  36. int main(void)
  37. {
  38.     u8 datap[SIZE] =
  39.     { };
  40.     u16 Flash_Model = 0;

  42.     Delay_Init();
  43.     USART_Printf_Init(115200);
  44.     printf("SystemClk: %d\r\n", SystemCoreClock);

  46.     SPI_Flash_Init();

  48.     Flash_Model = SPI_Flash_ReadID();
  49.     printf("Flash_Model:%x\r\n", Flash_Model);
  50.     switch (Flash_Model)
  51.     {
  52.     case W25Q80:
  53.         printf("W25Q80 OK!\r\n");
  54.         break;

  56.     case W25Q16:
  57.         printf("W25Q16 OK!\r\n");
  58.         break;

  60.     case W25Q32:
  61.         printf("W25Q32 OK!\r\n");
  62.         break;

  64.     case W25Q64:
  65.         printf("W25Q64 OK!\r\n");
  66.         break;

  68.     case W25Q128:
  69.         printf("W25Q128 OK!\r\n");
  70.         break;

  72.     default:
  73.         printf("Failed!\r\n");
  74.         break;
  75.     }

  77.     printf("Start Erase W25Qxx ...\r\n");
  78.     SPI_Flash_Erase_Sector(0);
  79.     printf("W25Qxx Erase Finished!\r\n");

  81.     Delay_Ms(500);
  82.     printf("Start Read W25Qxx ...\r\n");
  83.     SPI_Flash_Read(datap, 0x0, SIZE);
  84.     printf("%s\r\n", datap);

  86.     Delay_Ms(500);
  87.     printf("Start Write W25Qxx ...\r\n");
  88.     SPI_Flash_Write((u8*) TEXT_Buf, 0, SIZE);
  89.     printf("W25Qxx Write Finished!\r\n");

  91.     Delay_Ms(500);
  92.     printf("Start Read W25Qxx ...\r\n");
  93.     SPI_Flash_Read(datap, 0x0, SIZE);
  94.     printf("%s\r\n", datap);

  96.     while (1)
  97.     {
  98.         Delay_Ms(1000);

  100.         printf("Start Read W25Qxx ...\r\n");
  101.         SPI_Flash_Read(datap, 0x0, SIZE);
  102.         printf("%s\r\n", datap);
  103.     }

  105.     return 0;
  106. }

复制代码


完整代码打包在此：

W25Q16.png

W25Q16.zip

140.24 KB, 下载次数: 5

使用特权

评论回复 赏

相关资料

caizhiwei
| 2020-12-4 22:23 | 显示全部楼层
赞一个，辛苦了楼主

使用特权

评论回复 赏
资深技术
| 2020-12-7 16:37 | 显示全部楼层
赞楼主，正准备试用在这个芯片

使用特权

评论回复 赏
扫描二维码，随时随地手机跟帖
返回列表 发新帖 我要提问
高级模式
B Color Image Link Quote Code 收费 Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

我要发帖 我要提问 投诉建议 申请版主

快速回复

您需要登录后才可以回帖
登录 | 注册
高级模式

论坛热帖

关闭

热门推荐上一条 /5 下一条

在线客服 快速回复 返回顶部 返回列表