【HM】STM32F407 HAL库 SPI读写FLASH W25Q128

已于 2024-03-15 15:58:17 修改
阅读量646 收藏 11
点赞数 11
分类专栏： STM32 / GD32 文章标签： stm32 嵌入式硬件 单片机
于 2024-03-15 15:56:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hmxm6/article/details/136742213
版权
本文详细介绍了如何在STM32F407微控制器上使用HAL库进行W25Q128闪存的SPI读写操作，包括SPI的不同工作模式设置、时钟配置以及硬件电路的配合，同时提供了相关的初始化、擦除、读写和状态检查函数。
摘要由CSDN通过智能技术生成

【HM】STM32F407 HAL库 SPI读写FLASH W25Q128

W25Q128芯片简介

查看数据手册W25Q128芯片的SPI总线工作模式0支持(0，0)和3(1，1)

在这里插入图片描述

SPI不同工作模式CPOL和CPHA

Mode 0 ： Clock Polarity (CPOL) = 0 and, Clock Phase (CPHA) = 0

Mode 1 ： CPOL = 0 and, CPHA = 1

Mode 2 ： CPOL = 1 and, CPHA = 0

Mode 3 ： CPOL = 1 and, CPHA = 1

配置SYS和时钟

https://blog.csdn.net/hmxm6/article/details/136636793

配置SPI

Mode：全双工主机模式

NSS：不使用片选

Prescaler (for Baud Rate)：波特率分配因子

CPOL：时钟极性

CPHA：时钟相位

image-20240315153020384
根据硬件电路配置SPI引脚
image-20240315153647090 image-20240315153629461 ##### 根据硬件电路配置SPI 片选引脚

测试程序

头文件
#ifndef __BSP_SPI_FLASH_H
#define __BSP_SPI_FLASH_H

#include "stm32f4xx.h"
#include "stdio.h"

/**************命令定义-开头*************/
#define W25X_WriteEnable		      0x06 
#define W25X_WriteDisable		      0x04 
#define W25X_ReadStatusReg		    0x05 
#define W25X_WriteStatusReg		  0x01 
#define W25X_ReadData			        0x03 
#define W25X_FastReadData		      0x0B 
#define W25X_FastReadDual		      0x3B 
#define W25X_PageProgram		      0x02 
#define W25X_BlockErase			      0xD8 
#define W25X_SectorErase		      0x20 
#define W25X_ChipErase			      0xC7 
#define W25X_PowerDown			      0xB9 
#define W25X_ReleasePowerDown	  0xAB 
#define W25X_DeviceID			        0xAB 
#define W25X_ManufactDeviceID   	0x90 
#define W25X_JedecDeviceID		    0x9F 

#define WIP_Flag                  0x01  /* Write In Progress (WIP) flag */
#define Dummy_Byte                0xFF
/**************命令定义-结尾*************/

#define SPI_FLASH_PageSize              256
#define SPI_FLASH_PerWritePageSize      256


// 	FLASH初始化
void SPI_FLASH_Init(SPI_HandleTypeDef hspi1);
// 	读写数据
uint8_t SPI_FLASH_ReadWrite(uint8_t txdata);

// 	读取ID
uint16_t SPI_FLASH_ReadManufactDeviceID(void);
uint16_t SPI_FLASH_ReadDeviceID(void);
uint32_t SPI_FLASH_ReadJedecDeviceID(void);

// 	写使能
void SPI_FLASH_WriteEnable(void);
//	进入掉电模式
void SPI_Flash_PowerDown(void);
//	唤醒
void SPI_Flash_WAKEUP(void);
// 	等待WIP(BUSY)标志被置0，即等待到FLASH内部数据写入完毕
void SPI_FLASH_WaitForWriteEnd(void);
//	对FLASH写入数据，调用本函数写入数据前需要先擦除扇区
void SPI_FLASH_BufferWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite);
//  对FLASH按页写入数据，调用本函数写入数据前需要先擦除扇区
void SPI_FLASH_PageWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite);
// 	读取FLASH数据
void SPI_FLASH_BufferRead(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead);


// 	擦除FLASH扇区
void SPI_FLASH_SectorErase(uint32_t SectorAddr);
//  擦除FLASH扇区，整片擦除
void SPI_FLASH_BulkErase(void);


// 片选拉低
void SPI_FLASH_CS_LOW(void);
// 片选拉高
void SPI_FLASH_CS_HIGH(void);

#endif
片选信号函数&初始化函数
#include "bsp_spi_flash.h"

SPI_HandleTypeDef spiFlashHandle;

void SPI_FLASH_Init(SPI_HandleTypeDef hspi1)
{
	spiFlashHandle = hspi1;
	SPI_FLASH_CS_HIGH();
}

void SPI_FLASH_CS_LOW(void)
{
	HAL_GPIO_WritePin(GPIOG, GPIO_PIN_6, GPIO_PIN_RESET);
}

void SPI_FLASH_CS_HIGH(void)
{
	HAL_GPIO_WritePin(GPIOG, GPIO_PIN_6, GPIO_PIN_SET);
}
SPI最底层读写函数
uint8_t SPI_FLASH_ReadWrite(uint8_t txdata)
{
    uint8_t rxdata;
    HAL_SPI_TransmitReceive(&spiFlashHandle, &txdata, &rxdata, 1, 1000);
    return rxdata; /* 返回收到的数据 */
}
读取芯片各种ID函数
uint16_t SPI_FLASH_ReadManufactDeviceID(void)
{
    uint16_t deviceid;
 
    SPI_FLASH_CS_LOW();
    SPI_FLASH_ReadWrite(W25X_ManufactDeviceID);   /* 发送读 ID 命令 */
    SPI_FLASH_ReadWrite(0);                        /* 写入一个字节 */
    SPI_FLASH_ReadWrite(0);
    SPI_FLASH_ReadWrite(0);
    deviceid = SPI_FLASH_ReadWrite(0xFF) << 8;     /* 读取高8位字节 */
    deviceid |= SPI_FLASH_ReadWrite(0xFF);         /* 读取低8位字节 */
    SPI_FLASH_CS_HIGH();
 
    return deviceid;
}

uint16_t SPI_FLASH_ReadDeviceID(void)
{
	uint32_t Temp = 0;
	SPI_FLASH_CS_LOW();
  SPI_FLASH_ReadWrite(W25X_DeviceID);
  SPI_FLASH_ReadWrite(0);
  SPI_FLASH_ReadWrite(0);
  SPI_FLASH_ReadWrite(0);
	
	Temp = SPI_FLASH_ReadWrite(0);
	SPI_FLASH_CS_HIGH();
	
	return Temp;
}


uint32_t SPI_FLASH_ReadJedecDeviceID(void)
{
	uint32_t Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;
	
	SPI_FLASH_CS_LOW();
	
	SPI_FLASH_ReadWrite(W25X_JedecDeviceID);
	
	Temp0 = SPI_FLASH_ReadWrite(0);
	Temp1 = SPI_FLASH_ReadWrite(0);
	Temp2 = SPI_FLASH_ReadWrite(0);
	
	Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;
	
	return Temp;
}
写使能&掉电&唤醒
void SPI_FLASH_WriteEnable(void)
{
  SPI_FLASH_CS_LOW();
  /* 发送写使能命令*/
  SPI_FLASH_ReadWrite(W25X_WriteEnable);
  SPI_FLASH_CS_HIGH();
}

void SPI_Flash_PowerDown(void)   
{ 
  SPI_FLASH_CS_LOW();
  /* 发送 掉电 命令 */
  SPI_FLASH_ReadWrite(W25X_PowerDown);
  SPI_FLASH_CS_HIGH();
}   

void SPI_Flash_WAKEUP(void)   
{
  SPI_FLASH_CS_LOW();
  /* 发上 上电 命令 */
  SPI_FLASH_ReadWrite(W25X_ReleasePowerDown);
  SPI_FLASH_CS_HIGH();
}
Flash擦除函数
void SPI_FLASH_SectorErase(uint32_t SectorAddr)
{
  /* 发送FLASH写使能命令 */
  SPI_FLASH_WriteEnable();
  SPI_FLASH_WaitForWriteEnd();
  
  SPI_FLASH_CS_LOW();
  
	/* 发送扇区擦除指令*/
  SPI_FLASH_ReadWrite(W25X_SectorErase);
  /*发送擦除扇区地址的高位*/
  SPI_FLASH_ReadWrite((SectorAddr & 0xFF0000) >> 16);
  /* 发送擦除扇区地址的中位 */
  SPI_FLASH_ReadWrite((SectorAddr & 0xFF00) >> 8);
  /* 发送擦除扇区地址的低位 */
  SPI_FLASH_ReadWrite(SectorAddr & 0xFF);
  
  SPI_FLASH_CS_HIGH();
	
  /* 等待擦除完毕*/
  SPI_FLASH_WaitForWriteEnd();
}


void SPI_FLASH_BulkErase(void)
{
  /* 发送FLASH写使能命令 */
  SPI_FLASH_WriteEnable();

  SPI_FLASH_CS_LOW();
	
  /* 发送整块擦除指令*/
  SPI_FLASH_ReadWrite(W25X_ChipErase);
  
  SPI_FLASH_CS_HIGH();

  /* 等待擦除完毕*/
  SPI_FLASH_WaitForWriteEnd();
}
等待到FLASH内部数据写入完毕
void SPI_FLASH_WaitForWriteEnd(void)
{
  uint8_t FLASH_Status = 0;

  SPI_FLASH_CS_LOW();

  /* 发送 读状态寄存器 命令 */
  SPI_FLASH_ReadWrite(W25X_ReadStatusReg);

  int SPITimeout = 1000;
  /* 若FLASH忙碌，则等待 */
  do
  {
    /* 读取FLASH芯片的状态寄存器 */
    FLASH_Status = SPI_FLASH_ReadWrite(Dummy_Byte);	 

    {
      if((SPITimeout--) == 0) 
      {
        //SPI_TIMEOUT_UserCallback(4);
        return;
      }
    } 
  }
  while ((FLASH_Status & WIP_Flag) == SET); /* 正在写入标志 */

  SPI_FLASH_CS_HIGH();
}
按页写数据
void SPI_FLASH_PageWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
  /* 发送FLASH写使能命令 */
  SPI_FLASH_WriteEnable();

  /* 选择FLASH: CS低电平 */
  SPI_FLASH_CS_LOW();
  /* 写页写指令*/
  SPI_FLASH_ReadWrite(W25X_PageProgram);
  /*发送写地址的高位*/
  SPI_FLASH_ReadWrite((WriteAddr & 0xFF0000) >> 16);
  /*发送写地址的中位*/
  SPI_FLASH_ReadWrite((WriteAddr & 0xFF00) >> 8);
  /*发送写地址的低位*/
  SPI_FLASH_ReadWrite(WriteAddr & 0xFF);

  if(NumByteToWrite > SPI_FLASH_PerWritePageSize)
  {
    NumByteToWrite = SPI_FLASH_PerWritePageSize;
		printf("SPI:SPI_FLASH_PageWrite too large!\r\n");
  }

  /* 写入数据*/
  while (NumByteToWrite--)
  {
    /* 发送当前要写入的字节数据 */
    SPI_FLASH_ReadWrite(*pBuffer);
    /* 指向下一字节数据 */
    pBuffer++;
  }

  /* 停止信号 FLASH: CS 高电平 */
  SPI_FLASH_CS_HIGH();

  /* 等待写入完毕*/
  SPI_FLASH_WaitForWriteEnd();
}
写数据
void SPI_FLASH_BufferWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
  uint8_t NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
	
	/*mod运算求余，若writeAddr是SPI_FLASH_PageSize整数倍，运算结果Addr值为0*/
  Addr = WriteAddr % SPI_FLASH_PageSize;
	
	/*差count个数据值，刚好可以对齐到页地址*/
  count = SPI_FLASH_PageSize - Addr;	
	/*计算出要写多少整数页*/
  NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
	/*mod运算求余，计算出剩余不满一页的字节数*/
  NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;

	 /* Addr=0,则WriteAddr 刚好按页对齐 aligned  */
  if (Addr == 0) 
  {
		/* NumByteToWrite < SPI_FLASH_PageSize */
    if (NumOfPage == 0) 
    {
      SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
    }
    else /* NumByteToWrite > SPI_FLASH_PageSize */
    {
			/*先把整数页都写了*/
      while (NumOfPage--)
      {
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
        WriteAddr +=  SPI_FLASH_PageSize;
        pBuffer += SPI_FLASH_PageSize;
      }
			
			/*若有多余的不满一页的数据，把它写完*/
      SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
    }
  }
	/* 若地址与 SPI_FLASH_PageSize 不对齐  */
  else 
  {
		/* NumByteToWrite < SPI_FLASH_PageSize */
    if (NumOfPage == 0) 
    {
			/*当前页剩余的count个位置比NumOfSingle小，写不完*/
      if (NumOfSingle > count) 
      {
        temp = NumOfSingle - count;
				
				/*先写满当前页*/
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
        WriteAddr +=  count;
        pBuffer += count;
				
				/*再写剩余的数据*/
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
      }
      else /*当前页剩余的count个位置能写完NumOfSingle个数据*/
      {				
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
      }
    }
    else /* NumByteToWrite > SPI_FLASH_PageSize */
    {
			/*地址不对齐多出的count分开处理，不加入这个运算*/
      NumByteToWrite -= count;
      NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
      NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;

      SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
      WriteAddr +=  count;
      pBuffer += count;
			
			/*把整数页都写了*/
      while (NumOfPage--)
      {
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
        WriteAddr +=  SPI_FLASH_PageSize;
        pBuffer += SPI_FLASH_PageSize;
      }
			/*若有多余的不满一页的数据，把它写完*/
      if (NumOfSingle != 0)
      {
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
      }
    }
  }
}
读取数据
void SPI_FLASH_BufferRead(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead)
{
  SPI_FLASH_CS_LOW();

  /* 发送 读 指令 */
  SPI_FLASH_ReadWrite(W25X_ReadData);

  /* 发送 读 地址高位 */
  SPI_FLASH_ReadWrite((ReadAddr & 0xFF0000) >> 16);
  /* 发送 读 地址中位 */
  SPI_FLASH_ReadWrite((ReadAddr& 0xFF00) >> 8);
  /* 发送 读 地址低位 */
  SPI_FLASH_ReadWrite(ReadAddr & 0xFF);
  
	/* 读取数据 */
  while (NumByteToRead--)
  {
    /* 读取一个字节*/
    *pBuffer = SPI_FLASH_ReadWrite(Dummy_Byte);
    /* 指向下一个字节缓冲区 */
    pBuffer++;
  }

  SPI_FLASH_CS_HIGH();
}
鸿喵小仙女
关注
  • 11
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ADS8688 STM32F407 HAL库 SPI驱动
08-09
ADS8688 16位500kAD采集芯片，使用STM32F407HAL库SPI驱动，源代码及CUBEMX配置工程解压即使用,使用正点原子核心板，具体引脚可在工程中自行修改
【STM32】BLDC驱动&控制开发笔记 | 07_SPI通信测试 - STM32F407用SPI配置DRV8323驱动芯片
这里是 F菌的进阶之路。
07-03 3431
使用STM32F407的SPI通信功能配置DRV8323S驱动芯片的详细过程说明。
SPI FLASH_W25Q64驱动 代码
zongguo的专栏
06-14 1万+
#include "flash.h" #include "spi.h" #include "delay.h"    #include "usart.h"    //////////////////////////////////////////////////////////////////////////////////  //本程序只供学习使用，未经作者许可，不得用于其它任
stm32f407读写flash的demo，基于正点原子探索者板
10-26
stm32f407读写flash的demo，基于正点原子探索者板，可以测试读写数字字母字符串，将stm32的flash当成eeprom读写
STM32F407.FLASH 读写经验
leolian
03-28 8285
现象:如下代码://从指定地址开始写入指定长度的数据//该函数对OTP区域也有效!可以用来写OTP区!//OTP区域地址范围:0X1FFF7800~0X1FFF7A0F//WriteAddr:起始地址(此地址必须为4的倍数!!)//pBuffer:数据指针//NumToWrite:字(32位)数(就是要写入的32位数据的个数.) void STMFLASH_Write(u32 WriteAddr,...
stm32读写内部Flash
weixin_47321452的博客
04-24 1500
stm32内部flash地址架构映射stm32内部flash地址架构映射因为我的stm32f407的内部flash是1M的所以块2不存在，但他的地址仍然存在，只是没有作用，这是stm32的整体框架。主存储器一般我们说 STM32 内部 FLASH 的时候，都是指这个主存储器区域，它是存储用户应用程序的空间，芯片型号说明中的 1M FLASH、2M FLASH 都是指这个区域的大小。
【HAL库】STM32F407----内部Flash的读写
MQ0522的博客
09-04 6372
【HAL库】STM32F407----内部Flash的读写
STM32F103和STM32F407的Flash读写基于 页和扇区
六月的雨
06-06 7883
STM32F1x和STM32F4x的Flash读写 1.理论：STM32f103的flash读写是基于 “页” STM32f407的flash读写是基于 “扇区” flash读写原理转自:https://blog.csdn.net/lushoumin/article/details/87694389?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162297841016780261913587%2522%252C%2522scm%2522%
STM32-F407使用SPI通讯协议读取与写入Flash数据
12-31
在本教程中，我们将重点讨论如何使用STM32-F407的SPI（Serial Peripheral Interface）通信协议来读取和写入W25Q128型闪存（Flash）中的数据。 W25Q128是一款串行EEPROM，容量为16MB，采用SPI接口，支持快速读取和...
STM32F407固件库-SPI—读写串行FLASH（W25Q128）.zip
05-29
该固件库示例主要展示了如何通过SPI（Serial Peripheral Interface）接口与W25Q128串行FLASH进行数据读写操作。W25Q128是一款容量为16MB的串行EEPROM，适用于存储大量非易失性数据。 在STM32F407中，SPI接口通常...
STM32F103标准库开发：W25Q128读写-程序源码
10-14
在本项目中，我们将探讨如何使用STM32的标准库（STM32CubeMX或HAL库）进行SPI通信，以实现对W25Q128外部闪存芯片的读写操作。 W25Q128是一款高容量的串行SPI闪存，具有128M位的存储空间，即16MB字节。该芯片被设计...
STM32F407 HAL库添加标准库中的delay函数
11-16
STM32F407 HAL库添加标准库中的delay函数，HAL库中只有HAL_Delay()函数实现延时，单位是ms，要实现us延时，不像标准库中delay_us()就可以了，所以增加了这个函数，来方便标准库转移到HAL库中的朋友使用习惯。
STM32F407 Flash操作笔记
热门推荐
xiaogu0322的博客
11-21 2万+
简述STM32F4XX的闪存擦除方式分为两种：扇区擦除（最小单元16K）和整片擦除。在实际应用中，为满足重要信息的存储，需将信息存入FLASH中，针对以上两种擦除方式，扇区擦除更符合实际的需要。
STM32 读写内部 Flash
xuechanba的博客
03-21 1282
野火的霸道，使用 STM32F407 单片机。完整工程已上传到资料库。
STM32F407ZG FLASH + 定时读写FLASH计数值
Suffocatingg的博客
08-24 2622
STM32F407ZG FLASH + 定时读写FLASH计数值
嵌入式_基于STM32F4标准库的Flash读写操作
Yin_w的博客
12-07 3152
在STM32芯片内有一个Flash存储器断电后数据不会丢失，所以Flash中经常存储一些关键数据，例如：运行的程序、属性文件、密钥、累计运行时间、故障日志等，所以Falsh读写操作非常重要。
STM32F4读写内部FLASH【使用库函数】
weixin_33766805的博客
11-09 3044
STM32F4Discovery开发帮使用的STM32F407VGT6芯片，内部FLASH有1M之多。平时写的代码，烧写完之后还有大量的剩余。有效利用这剩余的FLASH能存储不少数据。因此研究了一下STM32F4读写内部FLASH的一些操作。 【STM32F4 内部Flash的一些信息】 STM32F407VG的内部FLASH的地址是：0x08000000，大小是0x00100000。 写FLAS...
洋桃电子STM32F407单片机入门教程笔记二：嵌入式Flash读写
m0_61278502的博客
12-17 1465
在单片机内部集成了一块单片机存储器，相当于电脑的硬盘，可以存放我们下载的代码也可以存储程序运行中的临时数据，Flash存储器的特色是写入的数据在断电后不会丢失，但其写入速度比SRAM慢，所以我们的用户程序先下载到Flash存储器，单片机运行时的临时数据比如功能寄存器的操作、变量数值的修改都放在SRAM存储器中。但SRAM存储器中的数据掉电会丢失。当需要把临时数据保存则可以把临时数据写入Flash存储器。Flash读写功能就是在用户程序运行过程中自己操作Flash的数据读写。此功能在项目中的应用：
stm32-USART通信
最新发布
qq_50688173的博客
06-27 1350
全双工（Full Duplex）：USART在全双工模式下，可以同时发送和接收数据。它通常使用两个独立的数据线：TX（发送）和RX（接收）。全双工通信提高了数据传输的效率，因为发送和接收操作不会互相阻塞。半双工（Half Duplex）：虽然USART的硬件设计支持全双工，但它也可以配置为半双工模式。在半双工模式下，同一时间只能发送或接收数据，而不能同时进行。这种模式通常使用一根数据线（通常是TX/RX共用一根线），需要切换方向来发送或接收数据。单工（Simplex）
stm32f427HAL库spi3读写w25q32
05-19
以下是使用STM32F427 HAL库进行SPI3读写W25Q32的基本步骤： 1. 配置SPI3 ```c hspi3.Instance = SPI3; hspi3.Init.Mode = SPI_MODE_MASTER; hspi3.Init.Direction = SPI_DIRECTION_2LINES; hspi3.Init.DataSize = SPI_DATASIZE_8BIT; hspi3.Init.CLKPolarity = SPI_POLARITY_LOW; hspi3.Init.CLKPhase = SPI_PHASE_1EDGE; hspi3.Init.NSS = SPI_NSS_SOFT; hspi3.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2; hspi3.Init.FirstBit = SPI_FIRSTBIT_MSB; hspi3.Init.TIMode = SPI_TIMODE_DISABLE; hspi3.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE; hspi3.Init.CRCPolynomial = 10; HAL_SPI_Init(&hspi3); ``` 2. 配置GPIO引脚 ```c GPIO_InitStruct.Pin = GPIO_PIN_4; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; HAL_GPIO_Init(GPIOE, &GPIO_InitStruct); ``` 3. 读取ID ```c uint8_t rxData[2]; uint8_t txData[2]; txData[0] = 0x9F; // 发送读取ID命令 txData[1] = 0x00; HAL_GPIO_WritePin(GPIOE, GPIO_PIN_4, GPIO_PIN_RESET); // 使能W25Q32 HAL_SPI_TransmitReceive(&hspi3, txData, rxData, 2, 100); // 发送命令并接收数据 HAL_GPIO_WritePin(GPIOE, GPIO_PIN_4, GPIO_PIN_SET); // 禁用W25Q32 ``` 4. 读取数据 ```c uint8_t rxData[256]; uint8_t txData[256]; txData[0] = 0x03; // 发送读取数据命令 txData[1] = 0x00; txData[2] = 0x00; txData[3] = 0x00; HAL_GPIO_WritePin(GPIOE, GPIO_PIN_4, GPIO_PIN_RESET); // 使能W25Q32 HAL_SPI_Transmit(&hspi3, txData, 4, 1000); // 发送命令 HAL_SPI_Receive(&hspi3, rxData, 256, 1000); // 接收数据 HAL_GPIO_WritePin(GPIOE, GPIO_PIN_4, GPIO_PIN_SET); // 禁用W25Q32 ``` 5. 写入数据 ```c uint8_t txData[256]; txData[0] = 0x06; // 发送写使能命令 HAL_GPIO_WritePin(GPIOE, GPIO_PIN_4, GPIO_PIN_RESET); // 使能W25Q32 HAL_SPI_Transmit(&hspi3, txData, 1, 1000); // 发送命令 HAL_GPIO_WritePin(GPIOE, GPIO_PIN_4, GPIO_PIN_SET); // 禁用W25Q32 txData[0] = 0x02; // 发送写数据命令 txData[1] = 0x00; txData[2] = 0x00; txData[3] = 0x00; for (int i = 0; i < 256; i++) { txData[4 + i] = i; // 写入数据 } HAL_GPIO_WritePin(GPIOE, GPIO_PIN_4, GPIO_PIN_RESET); // 使能W25Q32 HAL_SPI_Transmit(&hspi3, txData, 260, 1000); // 发送命令和数据 HAL_GPIO_WritePin(GPIOE, GPIO_PIN_4, GPIO_PIN_SET); // 禁用W25Q32 ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值