搜索历史

清空
搜索热词
      0
      • 聊天消息
      • 系统消息
      • 评论与回复
      williamhill
      查看更多
      查看更多
      VIP于 到期 william hill官网
      登录后你可以
      • 下载海量资料
      • 学习在线课程
      • 观看威廉希尔官方网站 视频
      • 写文章/发帖/加入社区
      会员中心
      创作中心
      发布
      创作活动

      完善资料让更多小伙伴认识你，还能领取20积分哦，立即完善>

      3天内不再提示

      STM32CUBEMX开发GD32F303（16）----移植兆易创新SPI Nor Flash之GD25Q64Flash

      嵌入式单片机MCU开发 • 来源：嵌入式单片机MCU开发 • 作者：嵌入式单片机MCU开 • 2023-07-27 09:10 • 次阅读

      spi概述

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

      视频教学

      [https://www.bilibili.com/video/BV13g411z7gi/]

      csdn课程

      课程更加详细。
      [https://download.csdn.net/course/detail/37152]

      生成例程

      这里准备了自己绘制的开发板进行验证。

      在这里插入图片描述

      配置时钟树，配置时钟为64M。

      在这里插入图片描述

      查看原理图，PA9和PA10设置为开发板的串口。

      在这里插入图片描述

      配置串口。

      在这里插入图片描述

      由于需要输入数据，开启DMA进行接收。

      在这里插入图片描述

      中断。

      在这里插入图片描述

      SPI配置

      在开发板中有arduino接口，配置这几个接口为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串行同步时钟极性和相位可以通过寄存器配置，IOinterwetten与威廉的赔率体系 的SPI串行同步时钟需要根据从设备支持的时钟极性和相位来通讯。 最后，SPI接口的一个缺点：没有指定的流控制，没有应答机制确认是否接收到数据。
      在这里插入图片描述
      其中，CS是从芯片是否被主芯片选中的控制信号，也就是说只有片选信号为预先规定的使能信号时（高电位或低电位），主芯片对此从芯片的操作才有效。这就使在同一条总线上连接多个SPI设备成为可能。 随便配置一个端口为CS片选，并且命名为CS。

      在这里插入图片描述

      NOR Flash

      NOR Flash是一种非易失闪存威廉希尔官方网站 ，是Intel在1988年创建。是市场上两种主要的非易失闪存威廉希尔官方网站 之一。 以GD25Q64E为例，该 Flash为64M-bit大小，即8192K-Byte。
      在这里插入图片描述
      W25Q64将8M的容量分为127个块（Block),每个块大小为64K字节，每个块又分为16个扇区（Sector),每个扇区4K个字节。W25Q64的最小擦除单位为一个扇区，也就是每次必须擦除4K个字节。 即4K16128=8192K=8M

      在这里插入图片描述

      W25Q64的原理及应用

      复位初始化

      对于复位，需要发送0x66和0x99

      在这里插入图片描述

      代码中的初始化。

      /* Reset Operations */
#define RESET_ENABLE_CMD                     0x66
#define RESET_MEMORY_CMD                     0x99
/**
  * @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();

}

      在这里插入图片描述

      ID

      对于兆易创新W25Q64，主要有三种查询ID方式。

      在这里插入图片描述

      可以使用90H查询设备ID，以判断是否是W25Q64设备。

      在这里插入图片描述

      /* Identification Operations */
#define READ_ID_CMD                          0x9F
/**
  * @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();

}

      在这里插入图片描述

      读取数据

      对于兆易创新W25Q64，读取数据使用0x03指令，后面添加需要读取的数据地址。 数据可以一直进行读取，当不需要读取数据时候将片选CS拉高，关闭时钟SCLK即可。

      在这里插入图片描述

      #define READ_CMD                             0x03

/**
  * @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;
}

      以读取10个数据为例子，波形如下所示。

      BSP_W25Qx_Read(rData2,0x1000,0x00a);

      在这里插入图片描述

      擦除扇区

      最小的擦除单位是扇区，擦除指令为0x20和3字节的地址。

      在这里插入图片描述

      #define SECTOR_ERASE_CMD                     0x20
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;
}

      在这里插入图片描述

      写数据

      对于写数据到flash中，使用0x02指令进行写数据，后面还需要指定24位地址，才能进行写数据。

      在这里插入图片描述

      #define PAGE_PROG_CMD                        0x02
/**
  * @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;//0x100- > 256 bytes
  }
  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;
}

      对flash的0x1000地址进行写数据，指令如下。

      BSP_W25Qx_Write(wData2,0x1000,0x000a);

      波形如下所示。

      在这里插入图片描述

      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;//0x100- > 256 bytes
  }
  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 "stm32f1xx.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 */

      案例

      向0扇区（0块0扇区），17扇区（1块1扇区），34扇区（2块2扇区）分别写入0x200的数据。

      头文件定义

      /* USER CODE BEGIN Includes */
#include "stdio.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 "stm32f1xx_it.c"文件中断外部变量引用：

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

      串口2中断函数：

      /**
  * @brief This function handles USART2 global interrupt.
  */
void USART1_IRQHandler(void)
{
  /* USER CODE BEGIN USART2_IRQn 0 */

  /* USER CODE END USART2_IRQn 0 */
  HAL_UART_IRQHandler(&huart1);
  /* USER CODE BEGIN USART2_IRQn 1 */
    uint32_t temp;
    if(USART1 == huart1.Instance)//判断是否为串口2中断

    {      
        if(RESET != __HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE))//如果为串口2
        {
            __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 USART2_IRQn 1 */
}

      主程序

      读取ID和flash数据及擦除。

      /* USER CODE BEGIN 2 */
    printf("GD Nor Flash案例n");
     __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);//使能串口1 IDLE中断 

    /*##-1- Read the device ID  ########################*/ 
    BSP_W25Qx_Init();//初始化W25Q128
    BSP_W25Qx_Read_ID(ID);//读取ID

    if((ID[0] != 0xC8) | (ID[1] != 0x16))
    {
        Error_Handler();//如果 ID不对打印错误
    }
    else//ID正确，打印ID
    {
        printf("W25Q64 ID : ");
        for(i=0;i< 2;i++)
        {
            printf("0x%02X ",ID[i]);
        }
        printf("rnrn");
    }


/**************************读取第0扇区数据**************************************************************/

    /*##-3- Read the flash     ########################*/ 
    /*读取数据，rData读取数据的指针，起始地址0x00，读取数据长度0x200*/
    if(BSP_W25Qx_Read(rData1,0x0,0x200)== W25Qx_OK)
        printf("读取原始的0个扇区数据成功！n");
    else
        Error_Handler();
    /*打印数据*/    
    printf("读取原始的0个扇区数据为: rn");

    for(i =0;i< 0x200;i++)
    {
        if(i%20==0)
            printf("n0扇区第%d到%d的数据为：rn",i,i+19);
                printf("0x%02X  ",rData1[i]);
    }

    printf("n");


/**************************读取第17扇区数据**************************************************************/

    /*##-3- Read the flash     ########################*/ 
    /*读取数据，rData读取数据的指针，起始地址0x1000，读取数据长度0x200*/
    if(BSP_W25Qx_Read(rData2,0x11000,0x200)== W25Qx_OK)
        printf("读取原始的17个扇区数据成功！n");
    else
        Error_Handler();
    /*打印数据*/    
    printf("读取原始的2个扇区数据为:");

    for(i =0;i< 0x200;i++)
    {
        if(i%20==0)
            printf("n17扇区第%d到%d的数据为：rn",i,i+19);
                printf("0x%02X  ",rData2[i]);
    }

    printf("n");    


/**************************读取第34扇区数据**************************************************************/

    /*##-3- Read the flash     ########################*/ 
    /*读取数据，rData读取数据的指针，起始地址0x2000，读取数据长度0x200*/
    if(BSP_W25Qx_Read(rData3,0x22000,0x200)== W25Qx_OK)
        printf("读取原始的34个扇区数据成功！n");
    else
        Error_Handler();
    /*打印数据*/    
    printf("读取原始的34个扇区数据为: ");

    for(i =0;i< 0x200;i++)
    {
        if(i%20==0)
            printf("n34扇区第%d到%d的数据为：rn",i,i+19);
                printf("0x%02X  ",rData3[i]);
    }

    printf("n");    



/**************************清除第0扇区数据为0**************************************************************/



    /*##-2- Erase Block ##################################*/ 
    if(BSP_W25Qx_Erase_Block(0) == W25Qx_OK)
        printf(" QSPI Erase Block okrn");
    else
        Error_Handler();

    /*##-2- Written to the flash ########################*/ 
    /* fill buffer */
    printf(" 初始化数据，清零第0扇区前0x200的数据！rn");
    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("清零第0扇区前0x200的数据成功！rn");
    else
        Error_Handler();




    /*##-3- Read the flash     ########################*/ 
    /*读取数据，rData读取数据的指针，起始地址0x00，读取数据长度0x200*/
    if(BSP_W25Qx_Read(rData1,0x00,0x200)== W25Qx_OK)
        printf("读取第0扇区前0x200数据成功！rnrn");
    else
        Error_Handler();
    /*打印数据*/    
    printf("读取第0扇区前0x200数据为: rn");

    for(i =0;i< 0x200;i++)
    {
        if(i%20==0)
            printf("n第%d到%d的数据为：rn",i,i+19);
                printf("0x%02X  ",rData1[i]);
    }

    printf("n");


/**************************清除第17扇区数据为0**************************************************************/



    /*##-2- Erase Block ##################################*/ 
    if(BSP_W25Qx_Erase_Block(0x11000) == W25Qx_OK)
        printf(" QSPI Erase Block okrn");
    else
        Error_Handler();

    /*##-2- Written to the flash ########################*/ 
    /* fill buffer */
    printf(" 初始化数据，清零第17扇区前0x200的数据！rn");
    for(i =0;i< 0x200;i ++)
    {
            wData2[i] = 0;
          rData2[i] = 0;
    }
    /*写入数据，wData写入数据的指针，起始地址0x1000，写入数据长度0x200*/
    if(BSP_W25Qx_Write(wData2,0x11000,0x200)== W25Qx_OK)
        printf("清零第2扇区前0x200的数据成功！rn");
    else
        Error_Handler();




    /*##-3- Read the flash     ########################*/ 
    /*读取数据，rData读取数据的指针，起始地址0x00，读取数据长度0x200*/
    if(BSP_W25Qx_Read(rData2,0x11000,0x200)== W25Qx_OK)
        printf("读取第17扇区前0x200数据成功！rnrn");
    else
        Error_Handler();
    /*打印数据*/    
    printf("读取第17扇区前0x200数据为: rn");

    for(i =0;i< 0x200;i++)
    {
        if(i%20==0)
            printf("n第%d到%d的数据为：rn",i,i+19);
                printf("0x%02X  ",rData2[i]);
    }

    printf("n");


/**************************清除第34扇区数据为0**************************************************************/



    /*##-2- Erase Block ##################################*/ 
    if(BSP_W25Qx_Erase_Block(0x22000) == W25Qx_OK)
        printf(" QSPI Erase Block okrn");
    else
        Error_Handler();

    /*##-2- Written to the flash ########################*/ 
    /* fill buffer */
    printf(" 初始化数据，清零第34扇区前0x200的数据！rn");
    for(i =0;i< 0x200;i ++)
    {
            wData3[i] = 0;
          rData3[i] = 0;
    }
    /*写入数据，wData写入数据的指针，起始地址0x22000，写入数据长度0x200*/
    if(BSP_W25Qx_Write(wData3,0x22000,0x200)== W25Qx_OK)
        printf("清零第34扇区前0x200的数据成功！rn");
    else
        Error_Handler();




    /*##-3- Read the flash     ########################*/ 
    /*读取数据，rData读取数据的指针，起始地址0x00，读取数据长度0x200*/
    if(BSP_W25Qx_Read(rData3,0x22000,0x200)== W25Qx_OK)
        printf("读取第34扇区前0x200数据成功！rnrn");
    else
        Error_Handler();
    /*打印数据*/    
    printf("读取第34扇区前0x200数据为: rn");

    for(i =0;i< 0x200;i++)
    {
        if(i%20==0)
            printf("n第%d到%d的数据为：rn",i,i+19);
                printf("0x%02X  ",rData3[i]);
    }

    printf("n");


  /* USER CODE END 2 */

      主程序。

      /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
        uart2_data();
        HAL_Delay(100);

  }
  /* USER CODE END 3 */

      数据处理

      /* USER CODE BEGIN 4 */
void uart2_data(void)
{
    if(recv_end_flag ==1)//接收完成标志
    {


if(ReceiveBuff[0]==0x00)
        {
            printf("写入数据长度：%dn",Rx_len-2);
            for(int i =0;i< Rx_len-2;i++)
            {
                wData1[ (i+ReceiveBuff[1]) ] = ReceiveBuff[i+2];

            }


        /*##-2- Erase Block ##################################*/ 
        if(BSP_W25Qx_Erase_Block(0) == W25Qx_OK)
            printf(" QSPI Erase Block okrn");
        else
            Error_Handler();


        /*写入数据，wData写入数据的指针，起始地址0x00，写入数据长度0x200*/
        if(BSP_W25Qx_Write(wData1,0x00,0x200)== W25Qx_OK)

            printf("扇区0数据成功~~~~~~~~~~~~~~~~~~~~~~~~~~！rn");
        else
            Error_Handler();

        if(BSP_W25Qx_Read(rData1,0x00,0x200)== W25Qx_OK)
            printf("读取扇区0前0x200数据成功！rnrn");
        else
            Error_Handler();
        /*打印数据*/    
        printf("读取扇区0前0x200数据为: rn");

        for(i =0;i< 0x200;i++)
        {
            if(i%20==0)
                printf("n第%d到%d的数据为：rn",i,i+19);
                    printf("0x%02X  ",wData1[i]);
        }

        printf("n");

    }



    else if(ReceiveBuff[0]==0x17)
    {
            printf("写入数据长度：%dn",Rx_len-2);
            for(int i =0;i< Rx_len-2;i++)
            {
//                Data[i]=ReceiveBuff[i+2];
                wData2[ (i+ReceiveBuff[1]) ] = ReceiveBuff[i+2];
            }


        /*##-17- Erase Block ##################################*/ 
        if(BSP_W25Qx_Erase_Block(0x11000) == W25Qx_OK)
            printf(" QSPI Erase Block okrn");
        else
            Error_Handler();


        /*写入数据，wData写入数据的指针，起始地址0x11000，写入数据长度0x200*/
        if(BSP_W25Qx_Write(wData2,0x11000,0x200)== W25Qx_OK)

            printf("扇区17数据成功~~~~~~~~~~~~~~~~~~~~~~~~~~！rn");
        else
            Error_Handler();

        if(BSP_W25Qx_Read(rData2,0x11000,0x200)== W25Qx_OK)
            printf("读取扇区17前0x200数据成功！rnrn");
        else
            Error_Handler();
        /*打印数据*/    
        printf("读取扇区17前0x200数据为: rn");

        for(i =0;i< 0x200;i++)
        {
            if(i%20==0)
                printf("n第%d到%d的数据为：rn",i,i+19);
                    printf("0x%02X  ",rData2[i]);
        }

        printf("n");

    }        



    else if(ReceiveBuff[0]==0x34)
    {
            printf("写入数据长度：%dn",Rx_len-2);
            for(int i =0;i< Rx_len-2;i++)
            {
//                Data[i]=ReceiveBuff[i+2];
                wData3[ (i+ReceiveBuff[1]) ] = ReceiveBuff[i+2];
            }


        /*##-22- Erase Block ##################################*/ 
        if(BSP_W25Qx_Erase_Block(0x22000) == W25Qx_OK)
            printf(" QSPI Erase Block okrn");
        else
            Error_Handler();


        /*写入数据，wData写入数据的指针，起始地址0x22000，写入数据长度0x200*/
        if(BSP_W25Qx_Write(wData3,0x22000,0x200)== W25Qx_OK)

            printf("扇区34数据成功~~~~~~~~~~~~~~~~~~~~~~~~~~！rn");
        else
            Error_Handler();

        if(BSP_W25Qx_Read(rData3,0x22000,0x200)== W25Qx_OK)
            printf("读取扇区34前0x200数据成功！rnrn");
        else
            Error_Handler();
        /*打印数据*/    
        printf("读取扇区34前0x200数据为: rn");

        for(i =0;i< 0x200;i++)
        {
            if(i%20==0)
                printf("n第%d到%d的数据为：rn",i,i+19);
                    printf("0x%02X  ",rData3[i]);
        }

        printf("n");

    }    




        else
            printf("输入错误！");

    for(int i = 0; i <  Rx_len ; i++) //清空接收缓存区
    ReceiveBuff[i]=0;//置0
    Rx_len=0;//接收数据长度清零
    recv_end_flag=0;//接收标志位清零
        //开启下一次接收
    HAL_UART_Receive_DMA(&huart1,(uint8_t*)ReceiveBuff,BUFFERSIZE);
    }

}

/* USER CODE END 4 */

      演示

      W25Q64芯片型号的ID为0XEF17，下方读取为0XC816，所以读取成功。

      在这里插入图片描述

      开机会打印出0，17，34扇区的前0x200个数据。

      在这里插入图片描述

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

      在这里插入图片描述

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

      在这里插入图片描述

      输入：00 28 11 12 13 14 15 向扇区0的的40(28是十六进制)号位置开始写入数据11 12 13 14 15。

      在这里插入图片描述

      输入：17 10 aa bb 向扇区17的的16(10是十六进制)号位置开始写入数据aa bb。

      在这里插入图片描述
      审核编辑：汤梓红

      声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容侵权或者其他违规问题，请联系本站处理。 举报投诉
      • FlaSh
        FlaSh
        +关注

        关注

        10

        文章

        1634

        浏览量

        148006
      • SPI
        SPI
        +关注

        关注

        17

        文章

        1706

        浏览量

        91560
      • 兆易创新
        兆易创新
        +关注

        关注

        23

        文章

        605

        浏览量

        80623
      • stm32cubemx
        stm32cubemx
        +关注

        关注

        5

        文章

        283

        浏览量

        14806
      • gd32f303
        gd32f303
        +关注

        关注

        4

        文章

        38

        浏览量

        3691
      收藏 人收藏

        评论

        相关推荐

        STM32CUBEMX开发GD32F303（6）----GPIO输入函数说明

        本章STM32CUBEMX配置STM32F103，并且在GD32F303中进行开发，同时通过GD32303C_START
        的头像 发表于 11-25 16:06 •1573次阅读
        <b class='flag-5'>STM32CUBEMX</b><b class='flag-5'>开发</b><b class='flag-5'>GD32F303</b>（6）----GPIO输入函数说明

        STM32CUBEMX开发GD32F303（8）----USART收发配置

        本章STM32CUBEMX配置STM32F103，并且在GD32F303中进行开发，同时通过GD32303C_START
        的头像 发表于 11-29 10:40 •3180次阅读
        <b class='flag-5'>STM32CUBEMX</b><b class='flag-5'>开发</b><b class='flag-5'>GD32F303</b>（8）----USART收发配置

        STM32CUBEMX开发GD32F303（9）----USART通过DMA收发

        概述 本章STM32CUBEMX配置STM32F103，并且在GD32F303中进行开发，同时通过GD32303C_START
        的头像 发表于 11-29 11:15 •2123次阅读
        <b class='flag-5'>STM32CUBEMX</b><b class='flag-5'>开发</b><b class='flag-5'>GD32F303</b>（9）----USART通过DMA收发

        STM32CUBEMX开发GD32F303（1）----前期准备与烧录

        概述 在这使用STM32CUBEMX进行配置STM32F103，移植到兆易创新
        的头像 发表于 11-22 17:08 •3092次阅读
        <b class='flag-5'>STM32CUBEMX</b><b class='flag-5'>开发</b><b class='flag-5'>GD32F303</b>（1）----前期准备与烧录

        GD32F303固件库开发（1）----前期准备与烧录

        在这使用STM32CUBEMX进行配置STM32F103，移植到兆易创新
        的头像 发表于 11-23 11:15 •2751次阅读
        <b class='flag-5'>GD32F303</b>固件库<b class='flag-5'>开发</b>（1）----前期准备与烧录

        STM32CUBEMX开发GD32F303（3）----点亮LED

        以STM32CUBEMX创建STM32F103工程，同时移植在GD32F303中，同时通过J-LINK烧录GD32303C_START和
        的头像 发表于 11-23 11:43 •2668次阅读
        <b class='flag-5'>STM32CUBEMX</b><b class='flag-5'>开发</b><b class='flag-5'>GD32F303</b>（3）----点亮LED

        STM32CUBEMX开发GD32F303（4）----GPIO输出模式，速率测试、开漏和输出说明

        以STM32CUBEMX创建STM32F103工程，同时移植在GD32F303中，同时通过GD32303C_START
        的头像 发表于 11-25 11:49 •1851次阅读
        <b class='flag-5'>STM32CUBEMX</b><b class='flag-5'>开发</b><b class='flag-5'>GD32F303</b>（4）----GPIO输出模式，速率测试、开漏和输出说明

        STM32CUBEMX开发GD32F303（10）----双ADC轮询模式扫描多个通道

        本章STM32CUBEMX配置STM32F103，并且在GD32F303中进行开发，同时通过GD32303C_START
        的头像 发表于 11-29 17:38 •1838次阅读
        <b class='flag-5'>STM32CUBEMX</b><b class='flag-5'>开发</b><b class='flag-5'>GD32F303</b>（10）----双ADC轮询模式扫描多个通道

        STM32CUBEMX开发GD32F303（11）----ADC在DMA模式下扫描多个通道

        本章STM32CUBEMX配置STM32F103，并且在GD32F303中进行开发，同时通过GD32303C_START
        的头像 发表于 11-30 10:59 •2361次阅读
        <b class='flag-5'>STM32CUBEMX</b><b class='flag-5'>开发</b><b class='flag-5'>GD32F303</b>（11）----ADC在DMA模式下扫描多个通道

        STM32CUBEMX开发GD32F303（12）----输出PWM及修改PWM频率与占空比

        本章STM32CUBEMX配置STM32F103，并且在GD32F303中进行开发，同时通过开发板内进行验证。 本章主要配置定时器输出PWM
        的头像 发表于 11-30 14:40 •3865次阅读
        <b class='flag-5'>STM32CUBEMX</b><b class='flag-5'>开发</b><b class='flag-5'>GD32F303</b>（12）----输出PWM及修改PWM频率与占空比

        STM32CUBEMX开发GD32F303（14）----IIC之配置OLED

        本章STM32CUBEMX配置STM32F103，并且在GD32F303中进行开发，同时通过开发板内进行验证。
        的头像 发表于 07-26 13:52 •2037次阅读
        <b class='flag-5'>STM32CUBEMX</b><b class='flag-5'>开发</b><b class='flag-5'>GD32F303</b>（14）----IIC<b class='flag-5'>之</b>配置OLED

        STM32CUBEMX开发GD32F303（15）----外部中断EXTI

        本章STM32CUBEMX配置STM32F103，并且在GD32F303中进行开发，同时通过开发板内进行验证。 使用外部中断EXTI进行驱
        的头像 发表于 07-26 15:53 •1343次阅读
        <b class='flag-5'>STM32CUBEMX</b><b class='flag-5'>开发</b><b class='flag-5'>GD32F303</b>（15）----外部中断EXTI

        GD32F303固件库开发（16）----移植兆易创新SPI Nor Flash之GD25Q64Flash

        省空间，提供方便，正是出于这种简单易用的特性，越来越多的芯片集成了这种通信协议，比如 EEPROM，FLASH，实时时钟，AD转换器。 W25Q64 是一款SPI接口的Flash芯片
        的头像 发表于 07-26 16:14 •1729次阅读
        <b class='flag-5'>GD32F303</b>固件库<b class='flag-5'>开发</b>（<b class='flag-5'>16</b>）----<b class='flag-5'>移植</b><b class='flag-5'>兆</b><b class='flag-5'>易</b><b class='flag-5'>创新</b><b class='flag-5'>SPI</b> <b class='flag-5'>Nor</b> <b class='flag-5'>Flash</b><b class='flag-5'>之</b><b class='flag-5'>GD25Q64Flash</b>

        STM32CUBEMX开发GD32F303

        在这使用STM32CUBEMX进行配置STM32F103，移植到兆易创新
        的头像 发表于 07-27 09:32 •1595次阅读
        <b class='flag-5'>STM32CUBEMX</b><b class='flag-5'>开发</b><b class='flag-5'>GD32F303</b>

        STM32CUBEMX开发GD32F303（17）----内部Flash读写

        本章STM32CUBEMX配置STM32F103，并且在GD32F303中进行开发，同时通过开发板内进行验证。 本例程主要讲解如何对芯片自
        的头像 发表于 07-27 09:35 •1812次阅读
        <b class='flag-5'>STM32CUBEMX</b><b class='flag-5'>开发</b><b class='flag-5'>GD32F303</b>（17）----内部<b class='flag-5'>Flash</b>读写
        华秋（原“华强聚丰”）：
        电子发烧友
        华秋开发
        华秋电路(原"华强PCB")
        华秋商城(原"华强芯城")
        华秋智造
        My ElecFans
        APP
        网站地图
        英国威廉希尔公司网站
        william hill 中国
        电源/新能源
        MEMS/传感威廉希尔官方网站
        2018威廉希尔决赛赔率
        嵌入式威廉希尔官方网站
        制造/封装
        interwetten与威廉的赔率体系
        RF/无线
        接口/总线/驱动
        william hill
        EDA/IC设计
        存储威廉希尔官方网站
        wh867
        EMC/EMI设计
        连接器
        william hill官网
        LEDs
        汽车电子
        音视频及家电
        通信网络
        医疗电子
        人工智能
        虚拟现实
        可穿戴设备
        机器人
        安全设备/系统
        军用/航空电子
        移动通信
        工业控制
        便携设备
        触控感测
        物联网
        智能电网
        区块链
        新科技
        特色内容
        专栏推荐
        学院
        设计资源
        英国威廉希尔公司网站
        电子百科
        电子视频
        元器件知识
        工具箱
        VIP会员
        最新威廉希尔官方网站 文章
        社区
        小组
        论坛
        问答
        评测试用
        企业服务
        产品
        资料
        文章
        方案
        企业
        供应链服务
        硬件开发
        华秋电路
        华秋商城
        华秋智造
        nextPCB
        BOM配单
        媒体服务
        网站广告
        在线研讨会
        活动策划
        新闻发布
        新品发布
        小测验
        设计大赛
        华秋
        关于我们
        投资关系
        新闻动态
        加入我们
        联系我们
        举报投诉
        社交网络
        微博
        移动端
        发烧友APP
        硬声APP
        WAP
        联系我们
        广告合作
        王婉珠：wangwanzhu@elecfans.com
        内容合作
        黄晶晶：huangjingjing@elecfans.com
        内容合作（海外）
        张迎辉：mikezhang@elecfans.com
        供应链服务 PCB/IC/PCBA
        江良华：lanhu@huaqiu.com
        投资合作
        曾海银：zenghaiyin@huaqiu.com
        社区合作
        刘勇：liuyong@huaqiu.com
        华秋发烧友
        电子工程师社区
        华秋电路
        1-32层PCB打样·中小批量
        华秋商城
        元器件现货·全球代购·SmartBOM
        华秋智造
        SMT贴片·PCBA加工
        NextPCB
        PCB Manufacturer

        版权所有 © 湖南华秋数字科技有限公司

        长沙市望城经济威廉希尔官方网站 开发区航空路6号手机智能终端产业园2号厂房3层（0731-88081133）

        电子发烧友 （电路图） 湘公网安备43011202000918 工商网监认证工商网监 湘ICP备2023018690号-1