21ic电子技术开发论坛 › 单片机与嵌入式系统 › 沁恒USB蓝牙MCU › [沁恒CH32V17测评]SPI功能测试读写W25Q64
返回列表 发新帖我要提问

[单片机芯片] [沁恒CH32V17测评]SPI功能测试读写W25Q64

[复制链接]
533|0
abner_ma 发表于 2025-8-31 18:09 | 显示全部楼层 |阅读模式
spi, 测试, 读写, W25Q64, TE, IO
   CH32V307 是沁恒（WCH）推出的基于 RISCV 内核的高性能 MCU，其集成的 SPI（串行外设接口）模块具备高速、多主从模式、灵活数据格式等特性，可满足工业控制、通信传输、存储扩展等多种场景下的外设互联需求。
Q2.png
Q3.png

一、CH32V317 的 SPI核心功能。CH32V307 /317 的 SPI 模块支持 主模式（Master） 和 从模式（Slave），可实现 一主多从或多主多从的拓扑结构，核心功能包括：
1.数据同步传输：通过 SCK（串行时钟）、MOSI（主发从收）、MISO（主收从发）三线同步传输数据，时钟速率可灵活配置；
2.片选控制：支持硬件 NSS（从机选择）引脚或软件模拟片选，方便管理多个从设备（如多片 SPI 闪存、ADC 等）；
3.数据帧灵活配置：支持 8 位或 16 位数据帧长度，满足不同外设的数据宽度需求；
4.全双工/半双工/ simplex 模式：默认全双工（MOSI/MISO 同时传输），可配置为半双工（单线路双向传输）或 simplex（仅发送/仅接收），适配不同通信场景
二、关键工作特性
1. 高速传输性能
   最高 SCK 时钟频率可达 45MHz（基于 CH32V307 最高 144MHz 系统主频，时钟分频系数可配置为 2/4/8/16/32/64/128）；
   支持 SPI 模式 0~3（通过时钟极性 CPOL 和时钟相位 CPHA 组合配置），兼容绝大多数 SPI 外设（如 Flash、OLED、传感器等）。
2. 中断与 DMA 支持
    中断机制：支持发送缓冲区空、接收缓冲区满、传输完成、错误（如 CRC 错误、溢出错误）等中断，可通过中断服务函数实时处理数据传输；
    DMA 功能：SPI 可与片内 DMA 控制器联动，实现无 CPU 干预的高速数据传输，减少内核负担，适合大数据量连续传输场景（如高速 ADC 数据采集、批量数据存储）。
3. 数据安全性与校验
     集成 CRC 循环冗余校验 模块，支持对发送/接收数据自动计算 CRC 值，可用于校验数据传输完整性（如与具备 CRC 功能的外设配合，提升通信可靠性）；
     支持 SSM（软件从机管理）模式：可通过软件控制 NSS 引脚电平，灵活管理从机使能/禁用，避免硬件 NSS 引脚的限制。
4. 多 SPI 实例与引脚复用
    CH32V307 通常集成 2~3 个独立 SPI 外设（具体数量需参考芯片手册，如 CH32V307VCT6 含 SPI1、SPI2、SPI3），可同时连接多个不同类型的 SPI 设备；
     支持 引脚复用：SPI 引脚（SCK、MOSI、MISO、NSS）可映射到不同 GPIO 引脚，方便 PCB 布局设计。
三、典型应用场景
1. 存储扩展：连接 SPI Flash（如 W25Q 系列）、SPI EEPROM，实现程序存储或数据缓存；
2. 显示控制：驱动 SPI 接口的 OLED 显示屏（如 128x64 OLED）、TFT 屏（需配合显示控制器）；
3. 传感器通信：与 SPI 接口的传感器（如加速度计 ADXL345、温湿度传感器 SHT3x、ADC 芯片 ADS1256）通信，采集数据；
4. 工业控制：连接 SPI 接口的 PLC 模块、变频器、编码器，实现工业设备间的同步数据传输；
5. 外设桥接：通过 SPI 与其他通信模块（如 SPItoUART 芯片、SPItoCAN 芯片）配合，扩展通信接口。

  下面进行实际测试，读写SPI Flash（ W25Q 系列）实现程序存储或数据缓存，链接图
Q7.png
程序编写流程如下：
1 .初始化：初始化系统时钟、延时函数、调试串口和 SPI 外设。
2.识别 Flash：读取 Flash 的器件 ID，并打印其型号。
3.擦除测试：擦除 Flash 的第 0 个扇区（4KB）。
4.读取验证：读取刚擦除的扇区，确认数据全为 0xFF。
5.写入数据：将字符串 "CH32F103 SPI FLASH W25Qxx" 写入 Flash 的起始地址。
6..读取验证：再次从 Flash 起始地址读取数据，并打印出来，以验证写入是否成功。
复制
  1. /*
    

  2. Master：SPI1_SCK(PA5)、SPI1_MISO(PA6)、SPI1_MOSI(PA7)。
    

  3. 本例程演示 SPI 操作 Winbond W25Qxx SPIFLASH。
    

  4. 注：
    

  5. pins:
    

  6. CS —— PA2
    

  7. DO —— PA6(SPI1_MISO)
    

  8. WP —— 3.3V
    

  9. DI —— PA7(SPI1_MOSI)
    

  10. CLK —— PA5(SPI1_SCK)
    

  11. HOLD —— 3.3V
    


  12. 

  13. */
    


  14. 

  15. #include "debug.h"
    

  16. #include "string.h"
    


  17. 

  18. /* Winbond SPIFalsh ID */
    

  19. #define W25Q80 0XEF13
    

  20. #define W25Q16 0XEF14
    

  21. #define W25Q32 0XEF15
    

  22. #define W25Q64 0XEF16
    

  23. #define W25Q128 0XEF17
    


  24. 

  25. /* Winbond SPIFalsh Instruction List */
    

  26. #define W25X_WriteEnable 0x06
    

  27. #define W25X_WriteDisable 0x04
    

  28. #define W25X_ReadStatusReg 0x05
    

  29. #define W25X_WriteStatusReg 0x01
    

  30. #define W25X_ReadData 0x03
    

  31. #define W25X_FastReadData 0x0B
    

  32. #define W25X_FastReadDual 0x3B
    

  33. #define W25X_PageProgram 0x02
    

  34. #define W25X_BlockErase 0xD8
    

  35. #define W25X_SectorErase 0x20
    

  36. #define W25X_ChipErase 0xC7
    

  37. #define W25X_PowerDown 0xB9
    

  38. #define W25X_ReleasePowerDown 0xAB
    

  39. #define W25X_DeviceID 0xAB
    

  40. #define W25X_ManufactDeviceID 0x90
    

  41. #define W25X_JedecDeviceID 0x9F
    


  42. 

  43. /* Global define */
    


  44. 

  45. /* Global Variable */
    

  46. u8 SPI_FLASH_BUF[4096];
    

  47. const u8 TEXT_Buf[] = {"I LOVE CHINA,I LOVE bbs.21ic.com too! "};
    

  48. #define SIZE sizeof(TEXT_Buf)
    


  49. 

  50. /*********************************************************************
    

  51. * @fn SPI1_ReadWriteByte
    

  52. *
    

  53. * [url=/u/brief]@brief[/url] SPI1 read or write one byte.
    

  54. *
    

  55. * @param TxData - write one byte data.
    

  56. *
    

  57. * [url=/u/return]@return[/url] Read one byte data.
    

  58. */
    

  59. u8 SPI1_ReadWriteByte(u8 TxData)
    

  60. {
    

  61. u8 i = 0;
    


  62. 

  63. while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET)
    

  64. {
    

  65. i++;
    

  66. if(i > 200)
    

  67. return 0;
    

  68. }
    


  69. 

  70. SPI_I2S_SendData(SPI1, TxData);
    

  71. i = 0;
    


  72. 

  73. while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET)
    

  74. {
    

  75. i++;
    

  76. if(i > 200)
    

  77. return 0;
    

  78. }
    


  79. 

  80. return SPI_I2S_ReceiveData(SPI1);
    

  81. }
    


  82. 

  83. /*********************************************************************
    

  84. * @fn SPI_Flash_Init
    

  85. *
    

  86. * @brief Configuring the SPI for operation flash.
    

  87. *
    

  88. * @return none
    

  89. */
    

  90. void SPI_Flash_Init(void)
    

  91. {
    

  92. GPIO_InitTypeDef GPIO_InitStructure = {0};
    

  93. SPI_InitTypeDef SPI_InitStructure = {0};
    


  94. 

  95. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_SPI1, ENABLE);
    


  96. 

  97. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    

  98. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    

  99. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  100. GPIO_Init(GPIOA, &GPIO_InitStructure);
    

  101. GPIO_SetBits(GPIOA, GPIO_Pin_2);
    


  102. 

  103. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
    

  104. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    

  105. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  106. GPIO_Init(GPIOA, &GPIO_InitStructure);
    


  107. 

  108. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    

  109. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    

  110. GPIO_Init(GPIOA, &GPIO_InitStructure);
    


  111. 

  112. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
    

  113. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    

  114. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  115. GPIO_Init(GPIOA, &GPIO_InitStructure);
    


  116. 

  117. SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    

  118. SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
    

  119. SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
    

  120. SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
    

  121. SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
    

  122. SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
    

  123. SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
    

  124. SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
    

  125. SPI_InitStructure.SPI_CRCPolynomial = 7;
    

  126. SPI_Init(SPI1, &SPI_InitStructure);
    


  127. 

  128. SPI_Cmd(SPI1, ENABLE);
    

  129. }
    


  130. 

  131. /*********************************************************************
    

  132. * @fn SPI_Flash_ReadSR
    

  133. *
    

  134. * @brief Read W25Qxx status register.
    

  135. * ——BIT7 6 5 4 3 2 1 0
    

  136. * ——SPR RV TB BP2 BP1 BP0 WEL BUSY
    

  137. *
    

  138. * @return byte - status register value.
    

  139. */
    

  140. u8 SPI_Flash_ReadSR(void)
    

  141. {
    

  142. u8 byte = 0;
    


  143. 

  144. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
    

  145. SPI1_ReadWriteByte(W25X_ReadStatusReg);
    

  146. byte = SPI1_ReadWriteByte(0Xff);
    

  147. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
    


  148. 

  149. return byte;
    

  150. }
    


  151. 

  152. /*********************************************************************
    

  153. * @fn SPI_FLASH_Write_SR
    

  154. *
    

  155. * @brief Write W25Qxx status register.
    

  156. *
    

  157. * @param sr - status register value.
    

  158. *
    

  159. * @return none
    

  160. */
    

  161. void SPI_FLASH_Write_SR(u8 sr)
    

  162. {
    

  163. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
    

  164. SPI1_ReadWriteByte(W25X_WriteStatusReg);
    

  165. SPI1_ReadWriteByte(sr);
    

  166. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
    

  167. }
    


  168. 

  169. /*********************************************************************
    

  170. * @fn SPI_Flash_Wait_Busy
    

  171. *
    

  172. * @brief Wait flash free.
    

  173. *
    

  174. * @return none
    

  175. */
    

  176. void SPI_Flash_Wait_Busy(void)
    

  177. {
    

  178. while((SPI_Flash_ReadSR() & 0x01) == 0x01)
    

  179. ;
    

  180. }
    


  181. 

  182. /*********************************************************************
    

  183. * @fn SPI_FLASH_Write_Enable
    

  184. *
    

  185. * @brief Enable flash write.
    

  186. *
    

  187. * @return none
    

  188. */
    

  189. void SPI_FLASH_Write_Enable(void)
    

  190. {
    

  191. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
    

  192. SPI1_ReadWriteByte(W25X_WriteEnable);
    

  193. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
    

  194. }
    


  195. 

  196. /*********************************************************************
    

  197. * @fn SPI_FLASH_Write_Disable
    

  198. *
    

  199. * @brief Disable flash write.
    

  200. *
    

  201. * @return none
    

  202. */
    

  203. void SPI_FLASH_Write_Disable(void)
    

  204. {
    

  205. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
    

  206. SPI1_ReadWriteByte(W25X_WriteDisable);
    

  207. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
    

  208. }
    


  209. 

  210. /*********************************************************************
    

  211. * @fn SPI_Flash_ReadID
    

  212. *
    

  213. * @brief Read flash ID.
    

  214. *
    

  215. * @return Temp - FLASH ID.
    

  216. */
    

  217. u16 SPI_Flash_ReadID(void)
    

  218. {
    

  219. u16 Temp = 0;
    


  220. 

  221. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
    

  222. SPI1_ReadWriteByte(W25X_ManufactDeviceID);
    

  223. SPI1_ReadWriteByte(0x00);
    

  224. SPI1_ReadWriteByte(0x00);
    

  225. SPI1_ReadWriteByte(0x00);
    

  226. Temp |= SPI1_ReadWriteByte(0xFF) << 8;
    

  227. Temp |= SPI1_ReadWriteByte(0xFF);
    

  228. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
    


  229. 

  230. return Temp;
    

  231. }
    


  232. 

  233. /*********************************************************************
    

  234. * @fn SPI_Flash_Erase_Sector
    

  235. *
    

  236. * @brief Erase one sector(4Kbyte).
    

  237. *
    

  238. * @param Dst_Addr - 0 —— 2047
    

  239. *
    

  240. * @return none
    

  241. */
    

  242. void SPI_Flash_Erase_Sector(u32 Dst_Addr)
    

  243. {
    

  244. Dst_Addr *= 4096;
    

  245. SPI_FLASH_Write_Enable();
    

  246. SPI_Flash_Wait_Busy();
    

  247. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
    

  248. SPI1_ReadWriteByte(W25X_SectorErase);
    

  249. SPI1_ReadWriteByte((u8)((Dst_Addr) >> 16));
    

  250. SPI1_ReadWriteByte((u8)((Dst_Addr) >> 8));
    

  251. SPI1_ReadWriteByte((u8)Dst_Addr);
    

  252. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
    

  253. SPI_Flash_Wait_Busy();
    

  254. }
    


  255. 

  256. /*********************************************************************
    

  257. * @fn SPI_Flash_Read
    

  258. *
    

  259. * @brief Read data from flash.
    

  260. *
    

  261. * @param pBuffer -
    

  262. * ReadAddr -Initial address(24bit).
    

  263. * size - Data length.
    

  264. *
    

  265. * @return none
    

  266. */
    

  267. void SPI_Flash_Read(u8 *pBuffer, u32 ReadAddr, u16 size)
    

  268. {
    

  269. u16 i;
    


  270. 

  271. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
    

  272. SPI1_ReadWriteByte(W25X_ReadData);
    

  273. SPI1_ReadWriteByte((u8)((ReadAddr) >> 16));
    

  274. SPI1_ReadWriteByte((u8)((ReadAddr) >> 8));
    

  275. SPI1_ReadWriteByte((u8)ReadAddr);
    


  276. 

  277. for(i = 0; i < size; i++)
    

  278. {
    

  279. pBuffer[i] = SPI1_ReadWriteByte(0XFF);
    

  280. }
    


  281. 

  282. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
    

  283. }
    


  284. 

  285. /*********************************************************************
    

  286. * @fn SPI_Flash_Write_Page
    

  287. *
    

  288. * @brief Write data by one page.
    

  289. *
    

  290. * @param pBuffer -
    

  291. * WriteAddr - Initial address(24bit).
    

  292. * size - Data length.
    

  293. *
    

  294. * @return none
    

  295. */
    

  296. void SPI_Flash_Write_Page(u8 *pBuffer, u32 WriteAddr, u16 size)
    

  297. {
    

  298. u16 i;
    


  299. 

  300. SPI_FLASH_Write_Enable();
    

  301. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
    

  302. SPI1_ReadWriteByte(W25X_PageProgram);
    

  303. SPI1_ReadWriteByte((u8)((WriteAddr) >> 16));
    

  304. SPI1_ReadWriteByte((u8)((WriteAddr) >> 8));
    

  305. SPI1_ReadWriteByte((u8)WriteAddr);
    


  306. 

  307. for(i = 0; i < size; i++)
    

  308. {
    

  309. SPI1_ReadWriteByte(pBuffer[i]);
    

  310. }
    


  311. 

  312. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
    

  313. SPI_Flash_Wait_Busy();
    

  314. }
    


  315. 

  316. /*********************************************************************
    

  317. * @fn SPI_Flash_Write_NoCheck
    

  318. *
    

  319. * @brief Write data to flash.(need Erase)
    

  320. * All data in address rang is 0xFF.
    

  321. *
    

  322. * @param pBuffer -
    

  323. * WriteAddr - Initial address(24bit).
    

  324. * size - Data length.
    

  325. *
    

  326. * @return none
    

  327. */
    

  328. void SPI_Flash_Write_NoCheck(u8 *pBuffer, u32 WriteAddr, u16 size)
    

  329. {
    

  330. u16 pageremain;
    


  331. 

  332. pageremain = 256 - WriteAddr % 256;
    


  333. 

  334. if(size <= pageremain)
    

  335. pageremain = size;
    


  336. 

  337. while(1)
    

  338. {
    

  339. SPI_Flash_Write_Page(pBuffer, WriteAddr, pageremain);
    


  340. 

  341. if(size == pageremain)
    

  342. {
    

  343. break;
    

  344. }
    

  345. else
    

  346. {
    

  347. pBuffer += pageremain;
    

  348. WriteAddr += pageremain;
    

  349. size -= pageremain;
    


  350. 

  351. if(size > 256)
    

  352. pageremain = 256;
    

  353. else
    

  354. pageremain = size;
    

  355. }
    

  356. }
    

  357. }
    


  358. 

  359. /*********************************************************************
    

  360. * @fn SPI_Flash_Write
    

  361. *
    

  362. * @brief Write data to flash.(no need Erase)
    

  363. *
    

  364. * @param pBuffer -
    

  365. * WriteAddr - Initial address(24bit).
    

  366. * size - Data length.
    

  367. *
    

  368. * @return none
    

  369. */
    

  370. void SPI_Flash_Write(u8 *pBuffer, u32 WriteAddr, u16 size)
    

  371. {
    

  372. u32 secpos;
    

  373. u16 secoff;
    

  374. u16 secremain;
    

  375. u16 i;
    


  376. 

  377. secpos = WriteAddr / 4096;
    

  378. secoff = WriteAddr % 4096;
    

  379. secremain = 4096 - secoff;
    


  380. 

  381. if(size <= secremain)
    

  382. secremain = size;
    


  383. 

  384. while(1)
    

  385. {
    

  386. SPI_Flash_Read(SPI_FLASH_BUF, secpos * 4096, 4096);
    


  387. 

  388. for(i = 0; i < secremain; i++)
    

  389. {
    

  390. if(SPI_FLASH_BUF[secoff + i] != 0XFF)
    

  391. break;
    

  392. }
    


  393. 

  394. if(i < secremain)
    

  395. {
    

  396. SPI_Flash_Erase_Sector(secpos);
    


  397. 

  398. for(i = 0; i < secremain; i++)
    

  399. {
    

  400. SPI_FLASH_BUF[i + secoff] = pBuffer[i];
    

  401. }
    


  402. 

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

  404. }
    

  405. else
    

  406. {
    

  407. SPI_Flash_Write_NoCheck(pBuffer, WriteAddr, secremain);
    

  408. }
    


  409. 

  410. if(size == secremain)
    

  411. {
    

  412. break;
    

  413. }
    

  414. else
    

  415. {
    

  416. secpos++;
    

  417. secoff = 0;
    


  418. 

  419. pBuffer += secremain;
    

  420. WriteAddr += secremain;
    

  421. size -= secremain;
    


  422. 

  423. if(size > 4096)
    

  424. {
    

  425. secremain = 4096;
    

  426. }
    

  427. else
    

  428. {
    

  429. secremain = size;
    

  430. }
    

  431. }
    

  432. }
    

  433. }
    


  434. 

  435. /*********************************************************************
    

  436. * @fn SPI_Flash_Erase_Chip
    

  437. *
    

  438. * @brief Erase all FLASH pages.
    

  439. *
    

  440. * @return none
    

  441. */
    

  442. void SPI_Flash_Erase_Chip(void)
    

  443. {
    

  444. SPI_FLASH_Write_Enable();
    

  445. SPI_Flash_Wait_Busy();
    

  446. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
    

  447. SPI1_ReadWriteByte(W25X_ChipErase);
    

  448. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
    

  449. SPI_Flash_Wait_Busy();
    

  450. }
    


  451. 

  452. /*********************************************************************
    

  453. * @fn SPI_Flash_PowerDown
    

  454. *
    

  455. * @brief Enter power down mode.
    

  456. *
    

  457. * @return none
    

  458. */
    

  459. void SPI_Flash_PowerDown(void)
    

  460. {
    

  461. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
    

  462. SPI1_ReadWriteByte(W25X_PowerDown);
    

  463. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
    

  464. Delay_Us(3);
    

  465. }
    


  466. 

  467. /*********************************************************************
    

  468. * @fn SPI_Flash_WAKEUP
    

  469. *
    

  470. * @brief Power down wake up.
    

  471. *
    

  472. * @return none
    

  473. */
    

  474. void SPI_Flash_WAKEUP(void)
    

  475. {
    

  476. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
    

  477. SPI1_ReadWriteByte(W25X_ReleasePowerDown);
    

  478. GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
    

  479. Delay_Us(3);
    

  480. }
程序配置注意：
1. 时钟配置：需确保 SPI 时钟（SCK）频率不超过从设备的最大支持速率（如部分低速传感器仅支持 ≤10MHz SCK）；
2. 模式匹配：主从设备的 SPI 模式（CPOL/CPHA）、数据帧长度必须一致，否则会导致数据传输错误；
3. 中断/DMA 优先级：若多个 SPI 同时使用中断或 DMA，需合理配置优先级，避免数据丢失或传输冲突；
4. 引脚电平：CH32V307 的 SPI 引脚默认为推挽输出，需确认与从设备的电平匹配（如 3.3V 与 5V 设备需考虑电平转换，避免损坏芯片）。
5.关键函数解析：
SPI_Flash_ReadSR(): 发送 0x05 命令读取状态寄存器，主要用来检查 BUSY 位。
SPI_Flash_Wait_Busy(): 循环读取状态寄存器，直到 BUSY 位为 0。任何写操作（擦除、编程）后都必须等待。
SPI_FLASH_Write_Enable(): 发送 0x06 命令。在执行任何修改存储单元的操作前，必须写使能。
SPI_Flash_ReadID(): 发送 0x90 命令， followed by 3 dummy bytes and then reads 2 bytes (Manufacturer ID, Device ID).
SPI_Flash_Erase_Sector(u32 Dst_Addr): 发送 0x20 命令 + 24位地址，擦除指定 4KB 扇区。Dst_Addr 是扇区号，函数内部会 *4096 转换为字节地址。
SPI_Flash_Read(): 发送 0x03 命令 + 24位地址，然后连续读取数据。
SPI_Flash_Write_Page(): 发送 0x02 命令 + 24位地址，然后连续写入数据。一次最多写入一页（256字节），且不能跨页。
SPI_Flash_Write_NoCheck(): 封装了跨页写入的逻辑，但它要求目标区域已被擦除（值为 0xFF）。
SPI_Flash_Write(): 最智能的写函数。它先检查目标地址所在的 4K 扇区是否需要擦除（是否有非 0xFF 的字节），如果需要，则先读取整个扇区到缓存 SPI_FLASH_BUF，修改缓存中对应的部分，然后擦除整个扇区，最后将整个缓存写回。这确保了数据的安全性。

main函数：
复制
  1. int main(void)
    

  2. {
    

  3.     u8  datap[SIZE];
    

  4.     u16 Flash_Model;
    


  5. 

  6.     Delay_Init();
    

  7.     USART_Printf_Init(115200);
    

  8.     printf("SystemClk:%d\r\n", SystemCoreClock);
    


  9. 

  10.     SPI_Flash_Init();
    


  11. 

  12.     Flash_Model = SPI_Flash_ReadID();
    


  13. 

  14.     switch(Flash_Model)
    

  15.     {
    

  16.         case W25Q80:
    

  17.             printf("W25Q80 OK!\r\n");
    


  18. 

  19.             break;
    


  20. 

  21.         case W25Q16:
    

  22.             printf("W25Q16 OK!\r\n");
    


  23. 

  24.             break;
    


  25. 

  26.         case W25Q32:
    

  27.             printf("W25Q32 OK!\r\n");
    


  28. 

  29.             break;
    


  30. 

  31.         case W25Q64:
    

  32.             printf("W25Q64 OK!\r\n");
    


  33. 

  34.             break;
    


  35. 

  36.         case W25Q128:
    

  37.             printf("W25Q128 OK!\r\n");
    


  38. 

  39.             break;
    


  40. 

  41.         default:
    

  42.             printf("Fail!\r\n");
    


  43. 

  44.             break;
    

  45.     }
    

  46.     printf("Start Erase W25Qxx....\r\n");
    

  47.     SPI_Flash_Erase_Sector(0);
    

  48.     printf("W25Qxx Erase Finished!\r\n");
    


  49. 

  50.     Delay_Ms(500);
    

  51.     printf("Start Read W25Qxx....\r\n");
    

  52.     SPI_Flash_Read(datap, 0x0, SIZE);
    

  53.     printf("%s\r\n", datap);
    


  54. 

  55.     Delay_Ms(500);
    

  56.     printf("Start Write W25Qxx....\r\n");
    

  57.     SPI_Flash_Write((u8 *)TEXT_Buf, 0, SIZE);
    

  58.     printf("W25Qxx Write Finished!\r\n");
    


  59. 

  60.     Delay_Ms(500);
    

  61.     printf("Start Read W25Qxx....\r\n");
    

  62.     SPI_Flash_Read(datap, 0x0, SIZE);
    

  63.     printf("%s\r\n", datap);
    


  64. 

  65.     while(1)
    

  66.         ;
    

  67. }
Q1.png

回复

收藏 举报

相关帖子
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

abner_ma Image
认证：项目经理
简介：资深嵌入式开发工程师

104

主题

190

帖子

3

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