[沁恒CH32V17测评]SPI功能测试读写W25Q64
CH32V307 是沁恒（WCH）推出的基于 RISCV 内核的高性能 MCU，其集成的 SPI（串行外设接口）模块具备高速、多主从模式、灵活数据格式等特性，可满足工业控制、通信传输、存储扩展等多种场景下的外设互联需求。一、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 系列）实现程序存储或数据缓存，链接图
程序编写流程如下：
1 .初始化：初始化系统时钟、延时函数、调试串口和 SPI 外设。
2.识别 Flash：读取 Flash 的器件 ID，并打印其型号。
3.擦除测试：擦除 Flash 的第 0 个扇区（4KB）。
4.读取验证：读取刚擦除的扇区，确认数据全为 0xFF。
5.写入数据：将字符串 "CH32F103 SPI FLASH W25Qxx" 写入 Flash 的起始地址。
6..读取验证：再次从 Flash 起始地址读取数据，并打印出来，以验证写入是否成功。
/*
Master：SPI1_SCK(PA5)、SPI1_MISO(PA6)、SPI1_MOSI(PA7)。
本例程演示 SPI 操作 Winbond W25Qxx SPIFLASH。
注：
pins:
CS —— PA2
DO —— PA6(SPI1_MISO)
WP —— 3.3V
DI —— PA7(SPI1_MOSI)
CLK —— PA5(SPI1_SCK)
HOLD —— 3.3V
*/
#include "debug.h"
#include "string.h"
/* Winbond SPIFalsh ID */
#define W25Q80 0XEF13
#define W25Q16 0XEF14
#define W25Q32 0XEF15
#define W25Q64 0XEF16
#define W25Q128 0XEF17
/* Winbond SPIFalsh Instruction List */
#define W25X_WriteEnable 0x06
#define W25X_WriteDisable 0x04
#define W25X_ReadStatusReg 0x05
#define W25X_WriteStatusReg 0x01
#define W25X_ReadData 0x03
#define W25X_FastReadData 0x0B
#define W25X_FastReadDual 0x3B
#define W25X_PageProgram 0x02
#define W25X_BlockErase 0xD8
#define W25X_SectorErase 0x20
#define W25X_ChipErase 0xC7
#define W25X_PowerDown 0xB9
#define W25X_ReleasePowerDown 0xAB
#define W25X_DeviceID 0xAB
#define W25X_ManufactDeviceID 0x90
#define W25X_JedecDeviceID 0x9F
/* Global define */
/* Global Variable */
u8 SPI_FLASH_BUF;
const u8 TEXT_Buf[] = {"I LOVE CHINA,I LOVE bbs.21ic.com too! "};
#define SIZE sizeof(TEXT_Buf)
/*********************************************************************
* @fn SPI1_ReadWriteByte
*
* @brief SPI1 read or write one byte.
*
* @param TxData - write one byte data.
*
* @return Read one byte data.
*/
u8 SPI1_ReadWriteByte(u8 TxData)
{
u8 i = 0;
while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET)
{
i++;
if(i > 200)
return 0;
}
SPI_I2S_SendData(SPI1, TxData);
i = 0;
while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET)
{
i++;
if(i > 200)
return 0;
}
return SPI_I2S_ReceiveData(SPI1);
}
/*********************************************************************
* @fn SPI_Flash_Init
*
* @brief Configuring the SPI for operation flash.
*
* @return none
*/
void SPI_Flash_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure = {0};
SPI_InitTypeDef SPI_InitStructure = {0};
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_SPI1, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_SetBits(GPIOA, GPIO_Pin_2);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPI1, &SPI_InitStructure);
SPI_Cmd(SPI1, ENABLE);
}
/*********************************************************************
* @fn SPI_Flash_ReadSR
*
* @brief Read W25Qxx status register.
* ——BIT7 6 5 4 3 2 1 0
* ——SPR RV TB BP2 BP1 BP0 WEL BUSY
*
* @return byte - status register value.
*/
u8 SPI_Flash_ReadSR(void)
{
u8 byte = 0;
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
SPI1_ReadWriteByte(W25X_ReadStatusReg);
byte = SPI1_ReadWriteByte(0Xff);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
return byte;
}
/*********************************************************************
* @fn SPI_FLASH_Write_SR
*
* @brief Write W25Qxx status register.
*
* @param sr - status register value.
*
* @return none
*/
void SPI_FLASH_Write_SR(u8 sr)
{
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
SPI1_ReadWriteByte(W25X_WriteStatusReg);
SPI1_ReadWriteByte(sr);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
}
/*********************************************************************
* @fn SPI_Flash_Wait_Busy
*
* @brief Wait flash free.
*
* @return none
*/
void SPI_Flash_Wait_Busy(void)
{
while((SPI_Flash_ReadSR() & 0x01) == 0x01)
;
}
/*********************************************************************
* @fn SPI_FLASH_Write_Enable
*
* @brief Enable flash write.
*
* @return none
*/
void SPI_FLASH_Write_Enable(void)
{
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
SPI1_ReadWriteByte(W25X_WriteEnable);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
}
/*********************************************************************
* @fn SPI_FLASH_Write_Disable
*
* @brief Disable flash write.
*
* @return none
*/
void SPI_FLASH_Write_Disable(void)
{
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
SPI1_ReadWriteByte(W25X_WriteDisable);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
}
/*********************************************************************
* @fn SPI_Flash_ReadID
*
* @brief Read flash ID.
*
* @return Temp - FLASH ID.
*/
u16 SPI_Flash_ReadID(void)
{
u16 Temp = 0;
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
SPI1_ReadWriteByte(W25X_ManufactDeviceID);
SPI1_ReadWriteByte(0x00);
SPI1_ReadWriteByte(0x00);
SPI1_ReadWriteByte(0x00);
Temp |= SPI1_ReadWriteByte(0xFF) << 8;
Temp |= SPI1_ReadWriteByte(0xFF);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
return Temp;
}
/*********************************************************************
* @fn SPI_Flash_Erase_Sector
*
* @brief Erase one sector(4Kbyte).
*
* @param Dst_Addr - 0 —— 2047
*
* @return none
*/
void SPI_Flash_Erase_Sector(u32 Dst_Addr)
{
Dst_Addr *= 4096;
SPI_FLASH_Write_Enable();
SPI_Flash_Wait_Busy();
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
SPI1_ReadWriteByte(W25X_SectorErase);
SPI1_ReadWriteByte((u8)((Dst_Addr) >> 16));
SPI1_ReadWriteByte((u8)((Dst_Addr) >> 8));
SPI1_ReadWriteByte((u8)Dst_Addr);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
SPI_Flash_Wait_Busy();
}
/*********************************************************************
* @fn SPI_Flash_Read
*
* @brief Read data from flash.
*
* @param pBuffer -
* ReadAddr -Initial address(24bit).
* size - Data length.
*
* @return none
*/
void SPI_Flash_Read(u8 *pBuffer, u32 ReadAddr, u16 size)
{
u16 i;
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
SPI1_ReadWriteByte(W25X_ReadData);
SPI1_ReadWriteByte((u8)((ReadAddr) >> 16));
SPI1_ReadWriteByte((u8)((ReadAddr) >> 8));
SPI1_ReadWriteByte((u8)ReadAddr);
for(i = 0; i < size; i++)
{
pBuffer = SPI1_ReadWriteByte(0XFF);
}
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
}
/*********************************************************************
* @fn SPI_Flash_Write_Page
*
* @brief Write data by one page.
*
* @param pBuffer -
* WriteAddr - Initial address(24bit).
* size - Data length.
*
* @return none
*/
void SPI_Flash_Write_Page(u8 *pBuffer, u32 WriteAddr, u16 size)
{
u16 i;
SPI_FLASH_Write_Enable();
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
SPI1_ReadWriteByte(W25X_PageProgram);
SPI1_ReadWriteByte((u8)((WriteAddr) >> 16));
SPI1_ReadWriteByte((u8)((WriteAddr) >> 8));
SPI1_ReadWriteByte((u8)WriteAddr);
for(i = 0; i < size; i++)
{
SPI1_ReadWriteByte(pBuffer);
}
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
SPI_Flash_Wait_Busy();
}
/*********************************************************************
* @fn SPI_Flash_Write_NoCheck
*
* @brief Write data to flash.(need Erase)
* All data in address rang is 0xFF.
*
* @param pBuffer -
* WriteAddr - Initial address(24bit).
* size - Data length.
*
* @return none
*/
void SPI_Flash_Write_NoCheck(u8 *pBuffer, u32 WriteAddr, u16 size)
{
u16 pageremain;
pageremain = 256 - WriteAddr % 256;
if(size <= pageremain)
pageremain = size;
while(1)
{
SPI_Flash_Write_Page(pBuffer, WriteAddr, pageremain);
if(size == pageremain)
{
break;
}
else
{
pBuffer += pageremain;
WriteAddr += pageremain;
size -= pageremain;
if(size > 256)
pageremain = 256;
else
pageremain = size;
}
}
}
/*********************************************************************
* @fn SPI_Flash_Write
*
* @brief Write data to flash.(no need Erase)
*
* @param pBuffer -
* WriteAddr - Initial address(24bit).
* size - Data length.
*
* @return none
*/
void SPI_Flash_Write(u8 *pBuffer, u32 WriteAddr, u16 size)
{
u32 secpos;
u16 secoff;
u16 secremain;
u16 i;
secpos = WriteAddr / 4096;
secoff = WriteAddr % 4096;
secremain = 4096 - secoff;
if(size <= secremain)
secremain = size;
while(1)
{
SPI_Flash_Read(SPI_FLASH_BUF, secpos * 4096, 4096);
for(i = 0; i < secremain; i++)
{
if(SPI_FLASH_BUF != 0XFF)
break;
}
if(i < secremain)
{
SPI_Flash_Erase_Sector(secpos);
for(i = 0; i < secremain; i++)
{
SPI_FLASH_BUF = pBuffer;
}
SPI_Flash_Write_NoCheck(SPI_FLASH_BUF, secpos * 4096, 4096);
}
else
{
SPI_Flash_Write_NoCheck(pBuffer, WriteAddr, secremain);
}
if(size == secremain)
{
break;
}
else
{
secpos++;
secoff = 0;
pBuffer += secremain;
WriteAddr += secremain;
size -= secremain;
if(size > 4096)
{
secremain = 4096;
}
else
{
secremain = size;
}
}
}
}
/*********************************************************************
* @fn SPI_Flash_Erase_Chip
*
* @brief Erase all FLASH pages.
*
* @return none
*/
void SPI_Flash_Erase_Chip(void)
{
SPI_FLASH_Write_Enable();
SPI_Flash_Wait_Busy();
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
SPI1_ReadWriteByte(W25X_ChipErase);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
SPI_Flash_Wait_Busy();
}
/*********************************************************************
* @fn SPI_Flash_PowerDown
*
* @brief Enter power down mode.
*
* @return none
*/
void SPI_Flash_PowerDown(void)
{
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
SPI1_ReadWriteByte(W25X_PowerDown);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
Delay_Us(3);
}
/*********************************************************************
* @fn SPI_Flash_WAKEUP
*
* @brief Power down wake up.
*
* @return none
*/
void SPI_Flash_WAKEUP(void)
{
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 0);
SPI1_ReadWriteByte(W25X_ReleasePowerDown);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, 1);
Delay_Us(3);
}程序配置注意：
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函数：
int main(void)
{
u8datap;
u16 Flash_Model;
Delay_Init();
USART_Printf_Init(115200);
printf("SystemClk:%d\r\n", SystemCoreClock);
SPI_Flash_Init();
Flash_Model = SPI_Flash_ReadID();
switch(Flash_Model)
{
case W25Q80:
printf("W25Q80 OK!\r\n");
break;
case W25Q16:
printf("W25Q16 OK!\r\n");
break;
case W25Q32:
printf("W25Q32 OK!\r\n");
break;
case W25Q64:
printf("W25Q64 OK!\r\n");
break;
case W25Q128:
printf("W25Q128 OK!\r\n");
break;
default:
printf("Fail!\r\n");
break;
}
printf("Start Erase W25Qxx....\r\n");
SPI_Flash_Erase_Sector(0);
printf("W25Qxx Erase Finished!\r\n");
Delay_Ms(500);
printf("Start Read W25Qxx....\r\n");
SPI_Flash_Read(datap, 0x0, SIZE);
printf("%s\r\n", datap);
Delay_Ms(500);
printf("Start Write W25Qxx....\r\n");
SPI_Flash_Write((u8 *)TEXT_Buf, 0, SIZE);
printf("W25Qxx Write Finished!\r\n");
Delay_Ms(500);
printf("Start Read W25Qxx....\r\n");
SPI_Flash_Read(datap, 0x0, SIZE);
printf("%s\r\n", datap);
while(1)
;
}
模块确实强大，支持多种模式和高速传输
测试流程看起来很详细，从初始化到读写验证，每一步都很清楚
页:
[1]