打印
[应用相关]

STM32CUBEMX--SPI,W25Q128外部Flash移植

[复制链接]
1069|20
手机看帖
扫描二维码
随时随地手机跟帖
跳转到指定楼层
楼主
概述
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的开发板:


Flash就是淘宝上SPI接口的W25Q128模块。


使用特权

评论回复
沙发
keaibukelian|  楼主 | 2021-8-2 15:49 | 只看该作者
选择芯片型号

使用STM32CUBEMX选择芯片stm32f030r8,如下所示:


使用特权

评论回复
板凳
keaibukelian|  楼主 | 2021-8-2 15:49 | 只看该作者
配置时钟源

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


使用特权

评论回复
地板
keaibukelian|  楼主 | 2021-8-2 15:49 | 只看该作者
配置时钟树

STM32F0的最高主频到48M,所以配置48即可:


使用特权

评论回复
5
keaibukelian|  楼主 | 2021-8-2 15:50 | 只看该作者
串口配置

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


使用特权

评论回复
6
keaibukelian|  楼主 | 2021-8-2 15:50 | 只看该作者
开启DMA。

中断。

使用特权

评论回复
7
keaibukelian|  楼主 | 2021-8-2 15:51 | 只看该作者
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。



使用特权

评论回复
8
keaibukelian|  楼主 | 2021-8-2 15:52 | 只看该作者
生成工程设置

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


使用特权

评论回复
9
keaibukelian|  楼主 | 2021-8-2 15:53 | 只看该作者
生成代码

配置keil


使用特权

评论回复
10
keaibukelian|  楼主 | 2021-8-2 15:55 | 只看该作者
W25Q128的原理及应用
W25Q128将16M的容量分为256个块(Block),每个块大小为64K字节,每个块又分为16个扇区(Sector),每个扇区4K个字节。W25Q128的最小擦除单位为一个扇区,也就是每次必须擦除4K个字节。
芯片ID如下所示。

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



使用特权

评论回复
11
keaibukelian|  楼主 | 2021-8-2 15:56 | 只看该作者
驱动代码
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;
}


使用特权

评论回复
12
keaibukelian|  楼主 | 2021-8-2 15:57 | 只看该作者
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 */



使用特权

评论回复
13
keaibukelian|  楼主 | 2021-8-2 15:58 | 只看该作者
写好的W25Qx.c放入Src文件夹内,W25Qx.h放入Inc文件夹内,之后需要在keil中加入这2个文件。

使用特权

评论回复
14
keaibukelian|  楼主 | 2021-8-2 15:59 | 只看该作者
代码
本例程向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 */


使用特权

评论回复
15
keaibukelian|  楼主 | 2021-8-2 16:00 | 只看该作者
#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 */
}


使用特权

评论回复
16
keaibukelian|  楼主 | 2021-8-2 16:01 | 只看该作者
在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 */


使用特权

评论回复
17
keaibukelian|  楼主 | 2021-8-2 16:02 | 只看该作者
主程序。

  /* 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 */


使用特权

评论回复
18
keaibukelian|  楼主 | 2021-8-2 16:04 | 只看该作者
演示效果

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


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



使用特权

评论回复
19
keaibukelian|  楼主 | 2021-8-2 16:06 | 只看该作者
串口定义了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。



使用特权

评论回复
20
keaibukelian|  楼主 | 2021-8-2 16:08 | 只看该作者
输入:01 28 11 12 13 14 15
向扇区1的的40(28是十六进制)号位置开始写入数据11 12 13 14 15。


使用特权

评论回复
发新帖 我要提问
您需要登录后才可以回帖 登录 | 注册

本版积分规则

63

主题

4095

帖子

5

粉丝