STM32CUBEMX(13)--SPI，W25Q128外部Flash移植

已于 2022-03-19 13:59:02 修改
阅读量1.5w 收藏 69
点赞数 18
分类专栏： 单片机 #STM32 文章标签： 嵌入式 stm32 单片机 flash W25Q128
于 2021-06-14 13:14:32 首次发布
本文链接：https://blog.csdn.net/qq_24312945/article/details/117756829
版权
单片机 同时被 2 个专栏收录
249 篇文章 152 订阅
订阅专栏
#STM32
68 篇文章 23 订阅
订阅专栏

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 这两种模式。

视频教学

https://www.bilibili.com/video/BV1r64y1r7SP/

完整代码下载

https://download.csdn.net/download/qq_24312945/85002437

硬件准备

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

在这里插入图片描述

Flash就是淘宝上SPI接口的W25Q128模块。
在这里插入图片描述

选择芯片型号

使用STM32CUBEMX选择芯片stm32f030r8，如下所示：
在这里插入图片描述

配置时钟源

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

配置时钟树

STM32F0的最高主频到48M，所以配置48即可：
在这里插入图片描述

串口配置

本次实验使用的串口1进行串口通信，波特率配置为115200。
在这里插入图片描述

开启DMA。
在这里插入图片描述
中断。
在这里插入图片描述

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，从设备使能信号，由主设备控制。

接线方式

在这里插入图片描述

负责通讯的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
*                                       http://www.waveshare.net
*                                          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
*                                       http://www.waveshare.net
*                                          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[i]);
		}
		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[i]);
	}

	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[i]);
	}

	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[i]);
	}

	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[i] = 0;
		  rData1[i] = 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[i]);
	}

	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[i] = 0;
		  rData2[i] = 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[i]);
	}

	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[i] = 0;
		  rData3[i] = 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[i]);
	}

	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。
在这里插入图片描述
输入：01 28 11 12 13 14 15
向扇区1的的40(28是十六进制)号位置开始写入数据11 12 13 14 15。
在这里插入图片描述
输入：03 10 aa bb
向扇区3的的16(10是十六进制)号位置开始写入数据aa bb。
在这里插入图片描述

最后

以上的代码会在Q群里分享。QQ群：615061293。
或者关注微信公众号『记贴』，持续更新文章和学习资料,可加作者的微信交流学习!
在这里插入图片描述

记帖
关注
  • 18
    点赞
  • 踩
  • 69
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 11
    评论
专栏目录
47、W25Q128 存储器实验
嵌入式羊圈
12-07 1555
文章目录1、实验目的2、原理图3、代码实现 1、实验目的 通过 STM8 的 SPI 硬件接口读写 W25Q128 串行 FLASH 存储器。 2、原理图   W25Q128 的片选信号接在 PD7；主机接收引脚连接在 PC7；主机发送引脚连接 在 PC6；暂停引脚直接接在电源上，禁止暂停功能；锁存引脚直接连接在电源上， 禁止锁存功能。 3、代码实现 /*****************************************************************************
stm32f407 w25q128 SPI stm32cubemx+ uart dma+timer定时功能0.zip
05-13
总结来说，"stm32f407 w25q128 SPI stm32cubemx+ uart dma+timer定时功能0.zip"这个压缩包包含了一个STM32F407项目，该项目展示了如何在STM32CUBEMX的帮助下，利用SPI接口驱动W25Q128串行闪存，同时利用UART的DMA...
STM32 Cubemx配置SPI编程（使用Flash模块）
m0_49476241的博客
02-28 3535
本篇文章来为大家讲解一下Flash模块的使用方法，Flash模块这里选择W25Q64模块。W25Q64 是一款由 Winbond 公司生产的串行闪存存储器，属于其 W25Q 系列产品。以下是关于 W25Q64 模块的一些基本信息：存储容量：W25Q64 模块通常具有 64 Megabit（Mb）的存储容量，相当于 8 Megabyte（MB）。接口：W25Q64 采用串行外围接口（SPI）进行通信。SPI 接口是一种通用的、简单的串行通信协议，通常用于与微控制器、传感器和其他外设进行通信。
【STM32】标准库-SPI-DMA收发数据-读写Flash(W25Q256JV)-仿printf和scanf输入输出
06-29
采用STM32F429IGT6单片机，KeilMDK5.32版本 使用SysTick系统滴答定时器进行延时 LED_R、LED_G、LED_B分别为PH10,PH11,PH12 Key1为PA0，Key2为PC13 KEIL5下载配置有FLASH与SRAM 用SPI5与Flash芯片通信(W25Q256JV)，使用了DMA进行收发数据，SPI是同步通信，同时收发数据(其实仅与发TX同步，作为主器件，Tx产生波特率时钟SCK信号) 利用可变参数宏实现printf与scanf 定义了Flash输入输出结构体，利用了共用体 发送与接收缓冲区大小均为一个扇区大小4096B NSS(CS)采用软件控制，因为Flash芯片每发送玩一个指令都要把CS拉高。 注意点：因为TX产生SCK时钟，故需要TX的DMA优先级要比RX的优先级低，本次TX和RX的DMA使用的是一个DMA(DMA2)，因为当收发一个数据后，TX和RX的DMA出现仲裁，TX需要发下一个数据，RX需要接收当前数据，为了防止一直发数据，故RX的DMA优先级需要比TX的高开启RX的DMA传输完成中断，在该中断中将CS拉高，结束通讯。
Arduino应用开发——spi flash（以esp32和w25qxx为例）
ShenZhen_zixian的博客
03-08 1万+
flash是我们在做嵌入式开发时一定会用到的，因为MCU本身就要使用flash来存储代码，flash的好处是掉电不会丢数据，只是一般MCU本身flash的容量都不大，如果我们需要存储大量的数据，就需要外接flash。 flash常用spi接口的，与传感器，电源IC这些芯片不同，不同型号和厂商的flash芯片在通讯协议和内部寄存器这些方面很统一，这对我们开发而言有着很大的好处，这意味着我们的驱动代码可以兼容各种各样的flash，可以在不改代码的基础上直接替换。...
W25Q128芯片手册精读
Edwinwzy的博客
10-05 6017
之前写SPI通信的时候用到了W25Q128，其中对芯片手册的阅读我只写了我们所需要的的部分。这篇博客就对这个芯片进行详细的阅读并记录，文章可能会比较长，但绝对是结合了自己的理解进行阐述。芯片手册刚开始看的时候最大的拦路虎其实就是英文，看习惯了中文，直接看纯英文的手册着实让人觉得难受。不过看手册又不是考试，翻译软件一大堆，看不懂就复制粘贴翻译一下也非常OK。翻译唯一不足的地方就是可能机翻可能不太准确，有些专业名词就通俗解释了。这篇博客就按照winbond公司的W25Q128芯片手册来阐述。
#芯片# W25Q128
Kshine2017的博客
09-24 7185
W25Q128JV 128Mbit 串行Flash存储器 1. 信息 该存储器先划分为256个可擦除块。每个块可以划分为16个扇区，每个扇区4KB。每个扇区可以划分为16个页。每页256字节。 即可以知道，共计65536可编程页， 4096个扇区，256个块。 存储框图 2. 写入数据 一次最多写入256字节。 3. 擦除数据 页被擦除时，可以按照16页一组（4KB的扇区大小）， 或者按照128页一组（32KB块大小）， 或者256页一组（64KB块）， 或者整个芯片 ..
STM32驱动W25Q64,W25Q128,W25QXX驱动
最新发布
03-20
STM32驱动W25Q64、W25Q128以及W25QXX系列的SPI接口闪存芯片是一项常见的任务，在嵌入式系统开发中扮演着重要角色。这些芯片通常用于存储程序代码、配置数据或者用户数据。在本教程中，我们将深入探讨如何使用STM32的...
使用STM32cubeMX/STM32cube ide 生成FatFS代码,操作SPI FLASH
04-19
在本文中，我们将深入探讨如何使用STM32CubeMX/STM32CubeIDE来生成FatFS代码，并操作SPI Flash（以w25Qxx为例），这在嵌入式硬件开发中是一个常见且重要的任务。STM32CubeMX是STMicroelectronics提供的一个配置工具...
W25Q256四字节模式读写程序
12-01
亲测可用的4字节nor flash读写程序， 经过优化可以直接使用，针对128M以上的FLASH可以直接使用，兼容128以下的芯片 已经应用到产品上，欢迎品鉴
stm32f407ZG 移植uc/OS-iii , 含有w25q128驱动
03-23
1. **SPI接口配置**：STM32F407ZG通过SPI接口与W25Q128通信，需要配置SPI时钟、数据线、片选信号等。 2. **命令序列**：理解并实现W25Q128的指令集，如读取、写入、擦除等操作。 3. **错误处理**：添加适当的错误...
SPI应用——W25Q128串行FLASH
qq_42878057的博客
03-30 4283
一.FLASH存储器介绍 FLASH存储器又称闪存，它与EEPROM都是掉电后数据不丢失的存储器，但FLASH存储器容量普遍大于EEPROM，现在基本取代了它的地位。在存储控制上，最主要的区别是FLASH芯片只能一大片一大片地擦写，而EEPROM可以单个字节擦写。 W25Q128是一种使用SPI通讯协议的NOR FLASH存储器，它的CS/CLK/DIO/DO引脚分别连接到了 STM32对应的SDI引脚NSS/SCK/MOSI/MISO上，其中STM32的NSS引脚是一个普通的GPIO，不是SPI的专用NS
笔记18:SPI之 芯片W25Q128简介
热门推荐
weixin_46468790的博客
09-16 2万+
一.STM32F407中的W25Q128与MCU连接原理图 工作电源： 2.7V to 3.6V 存储型矩阵: 一共有65,536页，每页256字节。每次只能写入一页，也就是每次只能写入256个字节。擦除时，只能以16页为最小单位，也就是一个扇区：16*256bits,一次就要擦8KB。 写入时可以以字节为单位写入，但是擦除时只能以扇区为单位擦除。 芯片支持标准的串行外设接口，比如SPI，也支持双IO-SPI或者四IO-SPI。 时钟：SPI clock frequencies of up to 104M
SPI与W25Q128
QJ敬的博客
03-31 864
SPI:即Serial Peripheral interface 串行外设接口(Motorala公司)SPI是一种的通信总线。全双工意味着至少需要两根数据线，串行意味着按bit发送，同步意味着通信双方共用时钟线。同样的SPI总线上也可以连接多个SPI设备，那么总线上的时钟由谁产生？谁产生都可以，只要同一时刻没有多个设备同时产生时钟就可以。通过谁去控制时钟线我们将设备分成：Master 主设备：产生时钟信号的设备Slave 从设备：接收时钟信号的设备。
RT-Thread Studio学习（十二）W25Q128(SPI)的读写
iqiaoqiao的博客
07-29 2146
本文将基于STM32F407ZGT芯片介绍如何在RT-ThreadStudio开发环境下访问W25Q128模块。
39_SPI通讯W25Q128实验
Yuanghxb的博客
12-13 841
SPI通讯W25Q128实验
arduino学习笔记
weixin_43461465的博客
02-09 389
arduino学习笔记 要了解arduino就先要了解什么是单片机，arduino平台的基础就是AVR指令集的单片机。 1.什么是单片机？它与个人计算机有什么不同？ 一台能够工作的计算机要有这样几个部份构成： 中央处理单元CPU（进行运算、控制）、随机存储器RAM（数据存储）、存储器ROM（程序存储）、输入/输出设备I/O（串行口、并行输出口等） 在个人计算机（PC）上这些部份被分成若干块芯片，安...
[10min速通]STM32CubemMX配置W25Q128
qq_34022877的博客
08-17 808
作者写的代码并没有提供多少注释，不过变量的命名已经可以做到见名知意。我通读了W25Qxx.c后，给大家介绍下常用的几个函数功能。
stm32cubemx w25q freertos
07-02
### 回答1： STM32CubeMX是STMicroelectronics（意法半导体）推出的一款嵌入式开发辅助工具，用于基于STM32微控制器的嵌入式应用程序开发。它可以帮助开发人员自动生成基础代码和初始化代码，从而减少开发时间和工作量。STM32CubeMX支持各种配置选项，如时钟配置、引脚配置、外设配置等，方便开发人员根据具体需求进行项目配置。 W25Q是一款由Winbond推出的SPI Flash存储器芯片，具有高速度、高可靠性和大容量等特点。它适用于各种应用领域，如消费电子产品、电视、路由器等。W25Q可以通过SPI接口与微控制器进行通信，实现数据存储和读取。 FreeRTOS是一款流行的实时操作系统内核，广泛应用于嵌入式系统中。它具有轻量级、可移植性强、开源等特点。FreeRTOS提供了多任务管理、中断处理、内存管理等功能，可以帮助开发人员实现复杂的嵌入式应用程序。 结合STM32CubeMX、W25Q和FreeRTOS，可以实现基于STM32微控制器的嵌入式系统的开发。首先，使用STM32CubeMX进行硬件配置，包括时钟配置、引脚配置、外设配置等。然后，根据具体需求编写应用程序代码，其中可以包括与W25Q进行通信的部分代码。最后，将编写的应用程序移植到FreeRTOS上，利用FreeRTOS提供的多任务管理功能进行任务调度和控制。 综上所述，使用STM32CubeMX、W25Q和FreeRTOS可以方便快速地开发基于STM32微控制器的嵌入式应用程序。这些工具和技术的结合可以提高开发效率和可靠性，同时也为嵌入式系统的功能扩展和优化提供了便利。 ### 回答2： STM32CubeMX是一款针对STMicroelectronics的STM32微控制器的图形化配置工具。它提供了一种简单易用的方式来生成驱动代码，帮助开发者快速搭建和配置STM32项目。 W25Q是一种串行闪存器件，可用于存储数据。它具有快速的读写速度和较大的存储容量，适合在嵌入式系统中使用。 FreeRTOS（即Real-Time Operating System）是一个开源的实时操作系统内核，可以帮助开发者构建可靠的、并发的、实时的嵌入式系统应用程序。 在STM32CubeMX中，我们可以使用W25Q作为外部存储，通过它来存储我们的应用程序数据或其他需要长期保存的数据。首先，我们需要在STM32CubeMX中配置MCU的外设和引脚资源，以使MCU能够与W25Q进行通信。然后，我们可以使用STM32CubeMX生成的初始化代码来驱动W25Q，如读取、写入数据等。 与此同时，我们还可以集成FreeRTOS来管理多个任务并实现实时性。在STM32CubeMX中，我们可以选择并配置FreeRTOS作为RTOS内核，然后生成与FreeRTOS相关的代码和配置。我们可以在生成的代码中定义和管理多个任务，并使用FreeRTOS提供的API来进行任务调度、资源管理、通信等操作。通过这种方式，我们可以实现高效、可靠、具有实时性的嵌入式系统。 总而言之，通过结合STM32CubeMX、W25Q和FreeRTOS，我们可以轻松实现复杂的嵌入式系统设计与开发。 ### 回答3： STM32CubeMX是一款用于快速配置STMicroelectronics STM32微控制器的软件工具。它为开发人员提供了一个简单易用的界面，可以自动生成初始化代码和驱动程序，从而加快了嵌入式系统的开发速度。 W25Q是一种串行闪存芯片，具有高密度存储和快速数据传输的特点。它可以作为存储设备，用于存储程序代码和其他数据。 FreeRTOS是一款实时操作系统，被广泛应用于嵌入式系统中。它提供了任务调度、内存管理、中断处理和通信机制等核心功能，使得开发者可以更轻松地实现多任务并发执行。 如果在STM32CubeMX中配置W25Q与FreeRTOS的集成，可以实现以下功能： 1. 配置W25Q作为外部存储器：通过STM32CubeMX选择W25Q作为外部存储器，并设置相应的引脚和时钟配置，从而使MCU能够与W25Q进行通信。 2. 生成W25Q驱动程序：STM32CubeMX可以自动生成与W25Q通信的驱动程序，以便开发者可以轻松地读写W25Q芯片的数据。 3. 集成FreeRTOS：通过STM32CubeMX配置FreeRTOS的内核和任务，以实现并行执行多个任务。可以创建一个或多个任务，其中一些可以负责与W25Q进行通信和存取数据。 通过以上配置，可以在嵌入式系统中实现对W25Q的读写操作，并在任务调度下实现多个任务的并发执行。这样，可以更好地利用STM32的硬件资源，并提高系统的性能和效率。这对于需要大容量存储和多任务处理的应用场景特别有用。
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

记帖

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值