【经验分享】STM32CUBEMX--SPI，W25Q128外部Flash移植

[复制链接]

STMCU小助手发布时间：2022-4-29 23:31

文章
文章封面:
文章简介:	STM32CUBEMX--SPI，W25Q128外部Flash移植

概述
SPI是串行外设接口（Serial Peripheral Interface）的缩写，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，正是出于这种简单易用的特性，越来越多的芯片集成了这种通信协议，比如 EEPROM，FLASH，实时时钟，AD转换器。
W25Q128 是一款SPI接口的Flash芯片，其存储空间为 128Mbit，相当于16M字节。W25Q128可以支持 SPI 的模式 0 和模式 3，也就是 CPOL=0/CPHA=0 和CPOL=1/CPHA=1 这两种模式。

硬件准备
首先需要准备一个开发板，这里我准备的是NUCLEO-F030R8的开发板：

H0)1(DOD46`N0X`9J48V~LL.png

选择芯片型号
使用STM32CUBEMX选择芯片stm32f030r8，如下所示：

配置时钟源
HSE与LSE分别为外部高速时钟和低速时钟，在本文中使用内置的时钟源，故都选择Disable选项，如下所示：

配置时钟树
STM32F0的最高主频到48M，所以配置48即可：

串口配置
本次实验使用的串口1进行串口通信，波特率配置为115200。

开启DMA。

$N_16%XT{@J)CZ)GTB]EIQDA.png$

中断。

VBII06W}JD]NLOB}ZFO}NCU.png

SPI配置
本次实验使用的SPI与Flash通信，配置如下。
SPI的通信原理很简单，它以主从方式工作，这种模式通常有一个主设备和一个或多个从设备，需要至少4根线，事实上3根也可以（单向传输时）。也是所有基于SPI的设备共有的，它们是MISO（主设备数据输入）、MOSI（主设备数据输出）、SCLK（时钟）、CS（片选）。
（1）MISO– Master Input Slave Output,主设备数据输入，从设备数据输出；
（2）MOSI– Master Output Slave Input，主设备数据输出，从设备数据输入；
（3）SCLK – Serial Clock，时钟信号，由主设备产生；
（4）CS – Chip Select，从设备使能信号，由主设备控制。

接线方式

(W7W[AN$X(90R]}GP`7_167.png

负责通讯的3根线了。通讯是通过数据交换完成的，这里先要知道SPI是串行通讯协议，也就是说数据是一位一位的传输的。这就是SCLK时钟线存在的原因，由SCLK提供时钟脉冲，SDI，SDO则基于此脉冲完成数据传输。数据输出通过 SDO线，数据在时钟上升沿或下降沿时改变，在紧接着的下降沿或上升沿被读取。完成一位数据传输，输入也使用同样原理。因此，至少需要8次时钟信号的改变（上沿和下沿为一次），才能完成8位数据的传输。
时钟信号线SCLK只能由主设备控制，从设备不能控制。同样，在一个基于SPI的设备中，至少有一个主设备。这样的传输方式有一个优点，在数据位的传输过程中可以暂停，也就是时钟的周期可以为不等宽，因为时钟线由主设备控制，当没有时钟跳变时，从设备不采集或传送数据。SPI还是一个数据交换协议：因为SPI的数据输入和输出线独立，所以允许同时完成数据的输入和输出。芯片集成的SPI串行同步时钟极性和相位可以通过寄存器配置，IO模拟的SPI串行同步时钟需要根据从设备支持的时钟极性和相位来通讯。
最后，SPI接口的一个缺点：没有指定的流控制，没有应答机制确认是否接收到数据。

其中，CS是从芯片是否被主芯片选中的控制信号，也就是说只有片选信号为预先规定的使能信号时（高电位或低电位），主芯片对此从芯片的操作才有效。这就使在同一条总线上连接多个SPI设备成为可能。
随便配置一个端口为CS片选，并且命名为CS。

生成工程设置
注意在生产工程设置中不能出现中文，不然会报错。

生成代码

配置keil

W25Q128的原理及应用
W25Q128将16M的容量分为256个块（Block),每个块大小为64K字节，每个块又分为16个扇区（Sector),每个扇区4K个字节。W25Q128的最小擦除单位为一个扇区，也就是每次必须擦除4K个字节。
芯片ID如下所示。

0XEF13,表示芯片型号为W25Q80
0XEF14,表示芯片型号为W25Q16
0XEF15,表示芯片型号为W25Q32
0XEF16,表示芯片型号为W25Q64
0XEF17,表示芯片型号为W25Q128

驱动代码
W25Qx.c

/*********************************************************************************************************
*
* File : ws_W25Qx.c
* Hardware Environment:
* Build Environment : RealView MDK-ARM Version: 4.20
* Version : V1.0
* By :
*
* (c) Copyright 2005-2011, WaveShare
* <a href="http://www.waveshare.net" target="_blank">http://www.waveshare.net</a>
* All Rights Reserved
*
*********************************************************************************************************/
#include "W25Qx.h"
/**
* @brief Initializes the W25Q128FV interface.
* @retval None
*/
uint8_t BSP_W25Qx_Init(void)
{
/* Reset W25Qxxx */
BSP_W25Qx_Reset();
return BSP_W25Qx_GetStatus();
}
/**
* @brief This function reset the W25Qx.
* @retval None
*/
static void BSP_W25Qx_Reset(void)
{
uint8_t cmd[2] = {RESET_ENABLE_CMD,RESET_MEMORY_CMD};
W25Qx_Enable();
/* Send the reset command */
HAL_SPI_Transmit(&hspi1, cmd, 2, W25Qx_TIMEOUT_VALUE);
W25Qx_Disable();
}
/**
* @brief Reads current status of the W25Q128FV.
* @retval W25Q128FV memory status
*/
static uint8_t BSP_W25Qx_GetStatus(void)
{
uint8_t cmd[] = {READ_STATUS_REG1_CMD};
uint8_t status;
W25Qx_Enable();
/* Send the read status command */
HAL_SPI_Transmit(&hspi1, cmd, 1, W25Qx_TIMEOUT_VALUE);
/* Reception of the data */
HAL_SPI_Receive(&hspi1,&status, 1, W25Qx_TIMEOUT_VALUE);
W25Qx_Disable();
/* Check the value of the register */
if((status & W25Q128FV_FSR_BUSY) != 0)
{
return W25Qx_BUSY;
}
else
{
return W25Qx_OK;
}
}
/**
* @brief This function send a Write Enable and wait it is effective.
* @retval None
*/
uint8_t BSP_W25Qx_WriteEnable(void)
{
uint8_t cmd[] = {WRITE_ENABLE_CMD};
uint32_t tickstart = HAL_GetTick();
/*Select the FLASH: Chip Select low */
W25Qx_Enable();
/* Send the read ID command */
HAL_SPI_Transmit(&hspi1, cmd, 1, W25Qx_TIMEOUT_VALUE);
/*Deselect the FLASH: Chip Select high */
W25Qx_Disable();
/* Wait the end of Flash writing */
while(BSP_W25Qx_GetStatus() == W25Qx_BUSY);
{
/* Check for the Timeout */
if((HAL_GetTick() - tickstart) > W25Qx_TIMEOUT_VALUE)
{
return W25Qx_TIMEOUT;
}
}
return W25Qx_OK;
}
/**
* @brief Read Manufacture/Device ID.
* @param return value address
* @retval None
*/
void BSP_W25Qx_Read_ID(uint8_t *ID)
{
uint8_t cmd[4] = {READ_ID_CMD,0x00,0x00,0x00};
W25Qx_Enable();
/* Send the read ID command */
HAL_SPI_Transmit(&hspi1, cmd, 4, W25Qx_TIMEOUT_VALUE);
/* Reception of the data */
HAL_SPI_Receive(&hspi1,ID, 2, W25Qx_TIMEOUT_VALUE);
W25Qx_Disable();
}
/**
* @brief Reads an amount of data from the QSPI memory.
* @param pData: Pointer to data to be read
* @param ReadAddr: Read start address
* @param Size: Size of data to read
* @retval QSPI memory status
*/
uint8_t BSP_W25Qx_Read(uint8_t* pData, uint32_t ReadAddr, uint32_t Size)
{
uint8_t cmd[4];
/* Configure the command */
cmd[0] = READ_CMD;
cmd[1] = (uint8_t)(ReadAddr >> 16);
cmd[2] = (uint8_t)(ReadAddr >> 8);
cmd[3] = (uint8_t)(ReadAddr);
W25Qx_Enable();
/* Send the read ID command */
HAL_SPI_Transmit(&hspi1, cmd, 4, W25Qx_TIMEOUT_VALUE);
/* Reception of the data */
if (HAL_SPI_Receive(&hspi1, pData,Size,W25Qx_TIMEOUT_VALUE) != HAL_OK)
{
return W25Qx_ERROR;
}
W25Qx_Disable();
return W25Qx_OK;
}
/**
* @brief Writes an amount of data to the QSPI memory.
* @param pData: Pointer to data to be written
* @param WriteAddr: Write start address
* @param Size: Size of data to write,No more than 256byte.
* @retval QSPI memory status
*/
uint8_t BSP_W25Qx_Write(uint8_t* pData, uint32_t WriteAddr, uint32_t Size)
{
uint8_t cmd[4];
uint32_t end_addr, current_size, current_addr;
uint32_t tickstart = HAL_GetTick();
/* Calculation of the size between the write address and the end of the page */
current_addr = 0;
while (current_addr <= WriteAddr)
{
current_addr += W25Q128FV_PAGE_SIZE;
}
current_size = current_addr - WriteAddr;
/* Check if the size of the data is less than the remaining place in the page */
if (current_size > Size)
{
current_size = Size;
}
/* Initialize the adress variables */
current_addr = WriteAddr;
end_addr = WriteAddr + Size;
/* Perform the write page by page */
do
{
/* Configure the command */
cmd[0] = PAGE_PROG_CMD;
cmd[1] = (uint8_t)(current_addr >> 16);
cmd[2] = (uint8_t)(current_addr >> 8);
cmd[3] = (uint8_t)(current_addr);
/* Enable write operations */
BSP_W25Qx_WriteEnable();
W25Qx_Enable();
/* Send the command */
if (HAL_SPI_Transmit(&hspi1,cmd, 4, W25Qx_TIMEOUT_VALUE) != HAL_OK)
{
return W25Qx_ERROR;
}
/* Transmission of the data */
if (HAL_SPI_Transmit(&hspi1, pData,current_size, W25Qx_TIMEOUT_VALUE) != HAL_OK)
{
return W25Qx_ERROR;
}
W25Qx_Disable();
/* Wait the end of Flash writing */
while(BSP_W25Qx_GetStatus() == W25Qx_BUSY);
{
/* Check for the Timeout */
if((HAL_GetTick() - tickstart) > W25Qx_TIMEOUT_VALUE)
{
return W25Qx_TIMEOUT;
}
}
/* Update the address and size variables for next page programming */
current_addr += current_size;
pData += current_size;
current_size = ((current_addr + W25Q128FV_PAGE_SIZE) > end_addr) ? (end_addr - current_addr) : W25Q128FV_PAGE_SIZE;
} while (current_addr < end_addr);
return W25Qx_OK;
}
/**
* @brief Erases the specified block of the QSPI memory.
* @param BlockAddress: Block address to erase
* @retval QSPI memory status
*/
uint8_t BSP_W25Qx_Erase_Block(uint32_t Address)
{
uint8_t cmd[4];
uint32_t tickstart = HAL_GetTick();
cmd[0] = SECTOR_ERASE_CMD;
cmd[1] = (uint8_t)(Address >> 16);
cmd[2] = (uint8_t)(Address >> 8);
cmd[3] = (uint8_t)(Address);
/* Enable write operations */
BSP_W25Qx_WriteEnable();
/*Select the FLASH: Chip Select low */
W25Qx_Enable();
/* Send the read ID command */
HAL_SPI_Transmit(&hspi1, cmd, 4, W25Qx_TIMEOUT_VALUE);
/*Deselect the FLASH: Chip Select high */
W25Qx_Disable();
/* Wait the end of Flash writing */
while(BSP_W25Qx_GetStatus() == W25Qx_BUSY);
{
/* Check for the Timeout */
if((HAL_GetTick() - tickstart) > W25Q128FV_SECTOR_ERASE_MAX_TIME)
{
return W25Qx_TIMEOUT;
}
}
return W25Qx_OK;
}
/**
* @brief Erases the entire QSPI memory.This function will take a very long time.
* @retval QSPI memory status
*/
uint8_t BSP_W25Qx_Erase_Chip(void)
{
uint8_t cmd[4];
uint32_t tickstart = HAL_GetTick();
cmd[0] = SECTOR_ERASE_CMD;
/* Enable write operations */
BSP_W25Qx_WriteEnable();
/*Select the FLASH: Chip Select low */
W25Qx_Enable();
/* Send the read ID command */
HAL_SPI_Transmit(&hspi1, cmd, 1, W25Qx_TIMEOUT_VALUE);
/*Deselect the FLASH: Chip Select high */
W25Qx_Disable();
/* Wait the end of Flash writing */
while(BSP_W25Qx_GetStatus() != W25Qx_BUSY);
{
/* Check for the Timeout */
if((HAL_GetTick() - tickstart) > W25Q128FV_BULK_ERASE_MAX_TIME)
{
return W25Qx_TIMEOUT;
}
}
return W25Qx_OK;
}

复制代码

W25Qx.h

/*********************************************************************************************************
*
* File : W25Qx.h
* Hardware Environment:
* Build Environment : RealView MDK-ARM Version: 5.15
* Version : V1.0
* By :
*
* (c) Copyright 2005-2015, WaveShare
* <a href="http://www.waveshare.net" target="_blank">http://www.waveshare.net</a>
* All Rights Reserved
*
*********************************************************************************************************/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __W25Qx_H
#define __W25Qx_H
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include "stm32f0xx.h"
#include "spi.h"
/** @addtogroup BSP
* @{
*/
/** @addtogroup Components
* @{
*/
/** @addtogroup W25Q128FV
* @{
*/
/** @defgroup W25Q128FV_Exported_Types
* @{
*/
/**
* @}
*/
/** @defgroup W25Q128FV_Exported_Constants
* @{
*/
/**
* @brief W25Q128FV Configuration
*/
#define W25Q128FV_FLASH_SIZE 0x1000000 /* 128 MBits => 16MBytes */
#define W25Q128FV_SECTOR_SIZE 0x10000 /* 256 sectors of 64KBytes */
#define W25Q128FV_SUBSECTOR_SIZE 0x1000 /* 4096 subsectors of 4kBytes */
#define W25Q128FV_PAGE_SIZE 0x100 /* 65536 pages of 256 bytes */
#define W25Q128FV_DUMMY_CYCLES_READ 4
#define W25Q128FV_DUMMY_CYCLES_READ_QUAD 10
#define W25Q128FV_BULK_ERASE_MAX_TIME 250000
#define W25Q128FV_SECTOR_ERASE_MAX_TIME 3000
#define W25Q128FV_SUBSECTOR_ERASE_MAX_TIME 800
#define W25Qx_TIMEOUT_VALUE 1000
/**
* @brief W25Q128FV Commands
*/
/* Reset Operations */
#define RESET_ENABLE_CMD 0x66
#define RESET_MEMORY_CMD 0x99
#define ENTER_QPI_MODE_CMD 0x38
#define EXIT_QPI_MODE_CMD 0xFF
/* Identification Operations */
#define READ_ID_CMD 0x90
#define DUAL_READ_ID_CMD 0x92
#define QUAD_READ_ID_CMD 0x94
#define READ_JEDEC_ID_CMD 0x9F
/* Read Operations */
#define READ_CMD 0x03
#define FAST_READ_CMD 0x0B
#define DUAL_OUT_FAST_READ_CMD 0x3B
#define DUAL_INOUT_FAST_READ_CMD 0xBB
#define QUAD_OUT_FAST_READ_CMD 0x6B
#define QUAD_INOUT_FAST_READ_CMD 0xEB
/* Write Operations */
#define WRITE_ENABLE_CMD 0x06
#define WRITE_DISABLE_CMD 0x04
/* Register Operations */
#define READ_STATUS_REG1_CMD 0x05
#define READ_STATUS_REG2_CMD 0x35
#define READ_STATUS_REG3_CMD 0x15
#define WRITE_STATUS_REG1_CMD 0x01
#define WRITE_STATUS_REG2_CMD 0x31
#define WRITE_STATUS_REG3_CMD 0x11
/* Program Operations */
#define PAGE_PROG_CMD 0x02
#define QUAD_INPUT_PAGE_PROG_CMD 0x32
/* Erase Operations */
#define SECTOR_ERASE_CMD 0x20
#define CHIP_ERASE_CMD 0xC7
#define PROG_ERASE_RESUME_CMD 0x7A
#define PROG_ERASE_SUSPEND_CMD 0x75
/* Flag Status Register */
#define W25Q128FV_FSR_BUSY ((uint8_t)0x01) /*!< busy */
#define W25Q128FV_FSR_WREN ((uint8_t)0x02) /*!< write enable */
#define W25Q128FV_FSR_QE ((uint8_t)0x02) /*!< quad enable */
#define W25Qx_Enable() HAL_GPIO_WritePin(CS_GPIO_Port, CS_Pin, GPIO_PIN_RESET)
#define W25Qx_Disable() HAL_GPIO_WritePin(CS_GPIO_Port, CS_Pin, GPIO_PIN_SET)
#define W25Qx_OK ((uint8_t)0x00)
#define W25Qx_ERROR ((uint8_t)0x01)
#define W25Qx_BUSY ((uint8_t)0x02)
#define W25Qx_TIMEOUT ((uint8_t)0x03)
uint8_t BSP_W25Qx_Init(void);
static void BSP_W25Qx_Reset(void);
static uint8_t BSP_W25Qx_GetStatus(void);
uint8_t BSP_W25Qx_WriteEnable(void);
void BSP_W25Qx_Read_ID(uint8_t *ID);
uint8_t BSP_W25Qx_Read(uint8_t* pData, uint32_t ReadAddr, uint32_t Size);
uint8_t BSP_W25Qx_Write(uint8_t* pData, uint32_t WriteAddr, uint32_t Size);
uint8_t BSP_W25Qx_Erase_Block(uint32_t Address);
uint8_t BSP_W25Qx_Erase_Chip(void);
/**
* @}
*/
/** @defgroup W25Q128FV_Exported_Functions
* @{
*/
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
#ifdef __cplusplus
}
#endif
#endif /* __W25Qx_H */

复制代码

写好的W25Qx.c放入Src文件夹内，W25Qx.h放入Inc文件夹内，之后需要在keil中加入这2个文件。

代码
本例程向1，2，3扇区中写入数据，并且读取出来，例程代码如下。
头文件定义。

/* USER CODE BEGIN Includes */
#include "stdio.h"
#include <string.h>
#include "W25Qx.h"
/* USER CODE END Includes */

复制代码

串口接收和flash数组定义。

/* USER CODE BEGIN PV */
#define BUFFERSIZE 255 //可以接收的最大字符个数
uint8_t ReceiveBuff[BUFFERSIZE]; //接收缓冲区
uint8_t recv_end_flag = 0,Rx_len;//接收完成中断标志，接收到字符长度
uint8_t wData1[0x200];
uint8_t wData2[0x200];
uint8_t wData3[0x200];
uint8_t rData1[0x200];
uint8_t rData2[0x200];
uint8_t rData3[0x200];
uint8_t ID[4];
uint32_t i;
uint8_t flag[1] ;
int i_flag = 0;
/* USER CODE END PV */

复制代码

串口重定向。

/* USER CODE BEGIN PFP */
void uart1_data(void); //接收函数
#ifdef __GNUC__ //串口重定向
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif
PUTCHAR_PROTOTYPE
{
HAL_UART_Transmit(&huart1 , (uint8_t *)&ch, 1, 0xFFFF);
return ch;
}
/* USER CODE END PFP */

复制代码

#include "stm32f0xx_it.c"文件中断外部变量引用：

/* USER CODE BEGIN 0 */
#define BUFFERSIZE 255 //可接收的最大数据量
extern uint8_t recv_end_flag,Rx_len,bootfirst;
/* USER CODE END 0 */

复制代码

串口1中断函数：

/**
* @brief This function handles USART1 global interrupt.
*/
void USART1_IRQHandler(void)
{
/* USER CODE BEGIN USART1_IRQn 0 */
/* USER CODE END USART1_IRQn 0 */
HAL_UART_IRQHandler(&huart1);
/* USER CODE BEGIN USART1_IRQn 1 */
uint32_t temp;
if(USART1 == huart1.Instance)//判断是否为串口1中断
{
if(RESET != __HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE))//如果为串口1
{
__HAL_UART_CLEAR_IDLEFLAG(&huart1);//清除中断标志
HAL_UART_DMAStop(&huart1);//停止DMA接收
temp = __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);//获取DMA当前还有多少未填充
Rx_len = BUFFERSIZE - temp; //计算串口接收到的数据个数
recv_end_flag = 1;
}
}
/* USER CODE END USART1_IRQn 1 */
}

复制代码

在main.c函数中，初始化串口和W25Q128。

/* USER CODE BEGIN 2 */
printf("串口1DMA例程\n");
__HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);//使能串口1 IDLE中断
printf("\r\n SPI-W25Q128读写\n");
/*##-1- Read the device ID ########################*/
BSP_W25Qx_Init();//初始化W25Q128
BSP_W25Qx_Read_ID(ID);//读取ID
if((ID[0] != 0xEF) | (ID[1] != 0x17))
{
Error_Handler();//如果 ID不对打印错误
}
else//ID正确，打印ID
{
printf("W25Q128 ID : ");
for(i=0;i<2;i++)
{
printf("0x%02X ",ID);
}
printf("\r\n\r\n");
}
/**************************读取第1扇区数据**************************************************************/
/*##-3- Read the flash ########################*/
/*读取数据，rData读取数据的指针，起始地址0x00，读取数据长度0x200*/
if(BSP_W25Qx_Read(rData1,0x0,0x200)== W25Qx_OK)
printf("读取原始的前1个扇区数据成功！\n");
else
Error_Handler();
/*打印数据*/
printf("读取原始的前1个扇区数据为: \r\n");
for(i =0;i<0x200;i++)
{
if(i%20==0)
printf("\n1扇区第%d到%d的数据为：\r\n",i,i+19);
printf("0x%02X ",rData1);
}
printf("\n");
/**************************读取第2扇区数据**************************************************************/
/*##-3- Read the flash ########################*/
/*读取数据，rData读取数据的指针，起始地址0x1000，读取数据长度0x200*/
if(BSP_W25Qx_Read(rData2,0x1000,0x200)== W25Qx_OK)
printf("读取原始的前2个扇区数据成功！\n");
else
Error_Handler();
/*打印数据*/
printf("读取原始的前2个扇区数据为:");
for(i =0;i<0x200;i++)
{
if(i%20==0)
printf("\n2扇区第%d到%d的数据为：\r\n",i,i+19);
printf("0x%02X ",rData2);
}
printf("\n");
/**************************读取第3扇区数据**************************************************************/
/*##-3- Read the flash ########################*/
/*读取数据，rData读取数据的指针，起始地址0x2000，读取数据长度0x200*/
if(BSP_W25Qx_Read(rData3,0x2000,0x200)== W25Qx_OK)
printf("读取原始的前3个扇区数据成功！\n");
else
Error_Handler();
/*打印数据*/
printf("读取原始的前3个扇区数据为: ");
for(i =0;i<0x200;i++)
{
if(i%20==0)
printf("\n3扇区第%d到%d的数据为：\r\n",i,i+19);
printf("0x%02X ",rData3);
}
printf("\n");
/**************************清除第1扇区数据为0**************************************************************/
/*##-2- Erase Block ##################################*/
if(BSP_W25Qx_Erase_Block(0) == W25Qx_OK)
printf(" QSPI Erase Block ok\r\n");
else
Error_Handler();
/*##-2- Written to the flash ########################*/
/* fill buffer */
printf(" 初始化数据，清零第1扇区前0x200的数据！\r\n");
for(i =0;i<0x200;i ++)
{
wData1 = 0;
rData1 = 0;
}
/*写入数据，wData写入数据的指针，起始地址0x00，写入数据长度0x200*/
if(BSP_W25Qx_Write(wData1,0x00,0x200)== W25Qx_OK)
printf("清零第1扇区前0x200的数据成功！\r\n");
else
Error_Handler();
/*##-3- Read the flash ########################*/
/*读取数据，rData读取数据的指针，起始地址0x00，读取数据长度0x200*/
if(BSP_W25Qx_Read(rData1,0x00,0x200)== W25Qx_OK)
printf("读取第1扇区前0x200数据成功！\r\n\r\n");
else
Error_Handler();
/*打印数据*/
printf("读取第1扇区前0x200数据为: \r\n");
for(i =0;i<0x200;i++)
{
if(i%20==0)
printf("\n第%d到%d的数据为：\r\n",i,i+19);
printf("0x%02X ",rData1);
}
printf("\n");
/**************************清除第2扇区数据为0**************************************************************/
/*##-2- Erase Block ##################################*/
if(BSP_W25Qx_Erase_Block(0x1000) == W25Qx_OK)
printf(" QSPI Erase Block ok\r\n");
else
Error_Handler();
/*##-2- Written to the flash ########################*/
/* fill buffer */
printf(" 初始化数据，清零第2扇区前0x200的数据！\r\n");
for(i =0;i<0x200;i ++)
{
wData2 = 0;
rData2 = 0;
}
/*写入数据，wData写入数据的指针，起始地址0x1000，写入数据长度0x200*/
if(BSP_W25Qx_Write(wData2,0x1000,0x200)== W25Qx_OK)
printf("清零第2扇区前0x200的数据成功！\r\n");
else
Error_Handler();
/*##-3- Read the flash ########################*/
/*读取数据，rData读取数据的指针，起始地址0x00，读取数据长度0x200*/
if(BSP_W25Qx_Read(rData2,0x1000,0x200)== W25Qx_OK)
printf("读取第2扇区前0x200数据成功！\r\n\r\n");
else
Error_Handler();
/*打印数据*/
printf("读取第2扇区前0x200数据为: \r\n");
for(i =0;i<0x200;i++)
{
if(i%20==0)
printf("\n第%d到%d的数据为：\r\n",i,i+19);
printf("0x%02X ",rData2);
}
printf("\n");
/**************************清除第3扇区数据为0**************************************************************/
/*##-2- Erase Block ##################################*/
if(BSP_W25Qx_Erase_Block(0x2000) == W25Qx_OK)
printf(" QSPI Erase Block ok\r\n");
else
Error_Handler();
/*##-2- Written to the flash ########################*/
/* fill buffer */
printf(" 初始化数据，清零第3扇区前0x200的数据！\r\n");
for(i =0;i<0x200;i ++)
{
wData3 = 0;
rData3 = 0;
}
/*写入数据，wData写入数据的指针，起始地址0x2000，写入数据长度0x200*/
if(BSP_W25Qx_Write(wData3,0x2000,0x200)== W25Qx_OK)
printf("清零第3扇区前0x200的数据成功！\r\n");
else
Error_Handler();
/*##-3- Read the flash ########################*/
/*读取数据，rData读取数据的指针，起始地址0x00，读取数据长度0x200*/
if(BSP_W25Qx_Read(rData3,0x2000,0x200)== W25Qx_OK)
printf("读取第3扇区前0x200数据成功！\r\n\r\n");
else
Error_Handler();
/*打印数据*/
printf("读取第3扇区前0x200数据为: \r\n");
for(i =0;i<0x200;i++)
{
if(i%20==0)
printf("\n第%d到%d的数据为：\r\n",i,i+19);
printf("0x%02X ",rData3);
}
printf("\n");
/* USER CODE END 2 */

复制代码

主程序。

/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
uart1_data();//串口数据处理
HAL_GPIO_WritePin(GPIOA,GPIO_PIN_5,GPIO_PIN_SET);
HAL_Delay(100);
HAL_GPIO_WritePin(GPIOA,GPIO_PIN_5,GPIO_PIN_RESET);
HAL_Delay(100);
}
/* USER CODE END 3 */

复制代码

演示效果
W25Q128芯片型号的ID为0XEF17，下方读取为0XEF17，所以读取成功。
开机会打印出1，2，3扇区的前0x200个数据，即打印2页的数据。

打印完原始数据之后将数据全部清零，清零完成如下图所示。

串口定义了ReceiveBuff[0]的数据为写入什么扇区，ReceiveBuff[0]为1写入扇区1，ReceiveBuff[0]为2写入扇区2，ReceiveBuff[0]为3写入扇区3，若为其他数据，则打印输入错误；ReceiveBuff[1]则为写入的位置。
输入：01 05 01 02 03 04
向扇区1的的05号位置开始写入数据01 02 03 04。