STM32硬件SPI驱动W25Qxx系列

已于 2024-03-27 10:18:26 修改
阅读量389 收藏 10
点赞数 9
文章标签： stm32 嵌入式硬件 单片机
于 2024-03-08 14:09:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50621510/article/details/136560583
版权

SPI配置

void MX_SPI1_Init(void)
{
  hspi1.Instance = SPI1;
  hspi1.Init.Mode = SPI_MODE_MASTER;
  hspi1.Init.Direction = SPI_DIRECTION_2LINES;
  hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi1.Init.NSS = SPI_NSS_SOFT;
  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
  hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi1.Init.CRCPolynomial = 10;
  if (HAL_SPI_Init(&hspi1) != HAL_OK)
  {
    Error_Handler();
  }
}

W25Qxx.c

#include "W25Qxx.h"

uint16_t W25QXX_TYPE;        //默认是W25Q32

//SPI读写一个字节
uint8_t SPI_ReadWriteByte(uint8_t data)
{
  uint8_t temp;
  
  HAL_SPI_TransmitReceive(&hspi1, &data, &temp, 1,0xff);
  
  return temp;
}

//SPI读多个字节
void SPI_ReadBytes(uint8_t *d_r,uint16_t len)
{
  HAL_SPI_Receive(&hspi1, d_r, len,0xffff);
}

//SPI写多少个字节
void SPI_WriteBytes(uint8_t *d_w,uint16_t len)
{
  HAL_SPI_Transmit(&hspi1, d_w,len,0xff);
}

//软件复位W25qXX
void W25XX_Reset_With_Soft(void)
{
  W25QXX_CS_L;                          //使能器件
  SPI_ReadWriteByte(W25X_Enable_Rest);  //发送允许复位命令
  W25QXX_CS_H;                          //取消片选   
  W25QXX_CS_L;                          //使能器件
  SPI_ReadWriteByte(W25X_Rest_Device);  //发送复位命令
  W25QXX_CS_H;                          //取消片选   
}
 
#if  ENABLE_W25Q256
//进入4字节地址模式	
void W25QXX_Enter_4Byte()
{
  W25QXX_CS_L;
  SPI_ReadWriteByte(W25X_Enter_4_Addres);  
  W25QXX_CS_H;
}
 
//退出4字节地址模式
void W25QXX_Exit_4Byte()
{
  W25QXX_CS_L;
  SPI_ReadWriteByte(W25X_Exit_4_Addres);  
  W25QXX_CS_H;
}
#endif

int W25QXX_Init(void)
{
  W25XX_Reset_With_Soft();
  for(int i=0;i<5;i++)
  {
    #if ENABLE_W25Q256
      W25QXX_Enter_4Byte();     //进入4字节模式
    #endif
    W25QXX_TYPE=W25QXX_ReadID();
    if(W25QXX_TYPE == W25Q256)
    {
      return 1;
    }
    else
    {
      HAL_Delay(10);
    }
  }
  return 0;
}

/********************************************************************************
//读取W25QXX的状态寄存器
//BIT7  6   5   4   3   2   1   0
//SPR   RV  TB BP2 BP1 BP0 WEL BUSY
//SPR:默认0,状态寄存器保护位,配合WP使用
//TB,BP2,BP1,BP0:FLASH区域写保护设置
//WEL:写使能锁定
//BUSY:忙标记位(1,忙;0,空闲)
//默认:0x00   
*******************************************************************************/
uint8_t W25QXX_Read_SR(void)   
{  
  uint8_t byte=0;   
  W25QXX_CS_L;                                  //使能器件   
  SPI_ReadWriteByte(W25X_ReadStatusReg);       //发送读取状态寄存器命令    
  byte=SPI_ReadWriteByte(0Xff);                //读取一个字节  
  W25QXX_CS_H;                                  //取消片选     
  return byte;   
}
 
/********************************************************************************
//写W25QXX状态寄存器
//只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!! 
*******************************************************************************/	
void W25QXX_Write_SR(uint8_t sr)   
{   
  W25QXX_CS_L;                                  //使能器件   
  SPI_ReadWriteByte(W25X_WriteStatusReg);      //发送写取状态寄存器命令    
  SPI_ReadWriteByte(sr);                       //写入一个字节  
  W25QXX_CS_H;                                  //取消片选     	      
} 
 
/********************************************************************************
//W25QXX写使能	
//将WEL置位 
*******************************************************************************/
void W25QXX_Write_Enable(void)   
{
  W25QXX_CS_L;                          //使能器件   
  SPI_ReadWriteByte(W25X_WriteEnable); //发送写使能  
  W25QXX_CS_H;                          //取消片选     	      
} 
 
/********************************************************************************
//W25QXX写禁止	
//将WEL清零 
*******************************************************************************/
void W25QXX_Write_Disable(void)   
{  
  W25QXX_CS_L;                                  //使能器件   
  SPI_ReadWriteByte(W25X_WriteDisable);        //发送写禁止指令    
  W25QXX_CS_H;                                  //取消片选     	      
} 	
 
/********************************************************************************
//读取芯片ID
//返回值如下:				   
//0XEF13,表示芯片型号为W25Q80  
//0XEF14,表示芯片型号为W25Q16    
//0XEF15,表示芯片型号为W25Q32  
//0XEF16,表示芯片型号为W25Q64 
//0XEF17,表示芯片型号为W25Q128 
//0XEF18,表示芯片型号为W25Q256 
*******************************************************************************/  
uint16_t W25QXX_ReadID(void)
{
  uint16_t Temp = 0;	  
  W25QXX_CS_L;				    
  SPI_ReadWriteByte(0x90);//发送读取ID命令	    
  SPI_ReadWriteByte(0x00); 	    
  SPI_ReadWriteByte(0x00); 	    
  SPI_ReadWriteByte(0x00); 	 			   
  Temp|=SPI_ReadWriteByte(0xFF)<<8;  
  Temp|=SPI_ReadWriteByte(0xFF);	 
  W25QXX_CS_H;				    
  return Temp;
}  
 
/********************************************************************************
//读取SPI FLASH  
//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区
//ReadAddr:开始读取的地址(24bit)（W25Q256为(32bit)）
//NumByteToRead:要读取的字节数(最大65535)
*******************************************************************************/
void W25QXX_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint32_t NumByteToRead)   
{ 										    
  W25QXX_CS_L;                                  //使能器件
  #if ENABLE_W25Q256
    SPI_ReadWriteByte(W25X_ReadData);          //发送4字节地址读取命令   
    SPI_ReadWriteByte((uint8_t)((ReadAddr)>>24));   //发送32bit地址
  #else
    SPI_ReadWriteByte(W25X_ReadData);          //发送普通读指令
  #endif
  SPI_ReadWriteByte((uint8_t)((ReadAddr)>>16));     //发送24bit地址    
  SPI_ReadWriteByte((uint8_t)((ReadAddr)>>8));   
  SPI_ReadWriteByte((uint8_t)ReadAddr);
  SPI_ReadBytes(pBuffer,NumByteToRead);
  W25QXX_CS_H;  				    	      
}

/********************************************************************************
//SPI在一页(0~65535)内写入少于256个字节的数据
//在指定地址开始写入最大256字节的数据
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)（W25Q256为(32bit)）
//NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!	
*******************************************************************************/
void W25QXX_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint32_t NumByteToWrite)
{
  W25QXX_Write_Enable();                                //SET WEL 
  W25QXX_CS_L;                                          //使能器件   
  SPI_ReadWriteByte(W25X_PageProgram);                  //发送写页命令  
  #if ENABLE_W25Q256                                    //发送读取命令   
    SPI_ReadWriteByte((uint8_t)((WriteAddr)>>24));      //发送32bit地址
  #endif
  SPI_ReadWriteByte((uint8_t)((WriteAddr)>>16));        //发送24bit地址    
  SPI_ReadWriteByte((uint8_t)((WriteAddr)>>8));   
  SPI_ReadWriteByte((uint8_t)WriteAddr);   
  SPI_WriteBytes(pBuffer,NumByteToWrite);
  W25QXX_CS_H;                                          //取消片选 
  W25QXX_Wait_Busy();                                   //等待写入结束
} 

/********************************************************************************
//无检验写SPI FLASH 
//必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
//具有自动换页功能 
//在指定地址开始写入指定长度的数据,但是要确保地址不越界!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)（W25Q256为(32bit)）
//NumByteToWrite:要写入的字节数(最大65535)
//CHECK OK
*******************************************************************************/
void W25QXX_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint32_t NumByteToWrite)   
{ 			 		 
  uint32_t pageremain;	   
  pageremain=256-WriteAddr%256;                                 //单页剩余的字节数		 	    
  if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;      //不大于256个字节
  while(1)
  {	   
    W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
    if(NumByteToWrite==pageremain)break;                        //写入结束了
    else                                                        //NumByteToWrite>pageremain
    {
      pBuffer+=pageremain;
      WriteAddr+=pageremain;	
      NumByteToWrite-=pageremain;                               //减去已经写入了的字节数
      if(NumByteToWrite>256)pageremain=256;                     //一次可以写入256个字节
      else pageremain=NumByteToWrite; 	                        //不够256个字节了
    }
  }	    
} 

/********************************************************************************
//写SPI FLASH  
//在指定地址开始写入指定长度的数据
//该函数带擦除操作!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)（W25Q256为(32bit)）						
//NumByteToWrite:要写入的字节数(最大65535) 
*******************************************************************************/
uint8_t W25QXX_BUFFER[4096];
void W25QXX_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint32_t NumByteToWrite)   
{ 
  uint32_t secpos;
  uint32_t secoff;
  uint32_t secremain;	   
  uint32_t i;    
  uint8_t *W25QXX_BUF;
	
  W25QXX_BUF=W25QXX_BUFFER;	     
  secpos=WriteAddr/4096;        //扇区地址  
  secoff=WriteAddr%4096;        //在扇区内的偏移
  secremain=4096-secoff;        //扇区剩余空间大小   
  if(NumByteToWrite<=secremain)secremain=NumByteToWrite;        //不大于4096个字节
  while(1) 
  {	
    W25QXX_Read(W25QXX_BUF,secpos*4096,4096);                   //读出整个扇区的内容
    for(i=0;i<secremain;i++)                    //校验数据
    {
      if(W25QXX_BUF[secoff+i]!=0XFF)break;      //需要擦除  	  
    }
    if(i<secremain)                     //需要擦除
    {
      W25QXX_Erase_Sector(secpos);      //擦除这个扇区
      for(i=0;i<secremain;i++)	        //复制
      {
        W25QXX_BUF[i+secoff]=pBuffer[i];	  
      }
      W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);        //写入整个扇区  
    }
    else 
      W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);        //写已经擦除了的,直接写入扇区剩余区间. 				   
    if(NumByteToWrite==secremain)break; //写入结束了
    else                                //写入未结束
    {
      secpos++;                         //扇区地址增1
      secoff=0;                         //偏移位置为0 	 
      pBuffer+=secremain;               //指针偏移
      WriteAddr+=secremain;             //写地址偏移	   
      NumByteToWrite-=secremain;        //字节数递减
      if(NumByteToWrite>4096)secremain=4096;    //下一个扇区还是写不完
      else secremain=NumByteToWrite;            //下一个扇区可以写完了
    }	 
  } 
}
 
/********************************************************************************
//擦除整个芯片		  
//等待时间超长...
*******************************************************************************/
void W25QXX_Erase_Chip(void)   
{                                   
  W25QXX_Write_Enable();                  //SET WEL 
  W25QXX_Wait_Busy();   
  W25QXX_CS_L;                            //使能器件   
  SPI_ReadWriteByte(W25X_ChipErase);     //发送片擦除命令  
  W25QXX_CS_H;                            //取消片选     	      
  W25QXX_Wait_Busy();   				  			  //等待芯片擦除结束
} 
 
/********************************************************************************
//擦除一个扇区
//Dst_Addr:扇区地址 根据实际容量设置
//擦除一个山区的最少时间:150ms
*******************************************************************************/
void W25QXX_Erase_Sector(uint32_t Dst_Addr)   
{	  
  Dst_Addr*=4096;
  W25QXX_Write_Enable();                        //SET WEL 	 
  W25QXX_Wait_Busy();   
  W25QXX_CS_L;                                  //使能器件   
  SPI_ReadWriteByte(W25X_SectorErase);         //发送扇区擦除指令 
  #if ENABLE_W25Q256                            //发送读取命令   
    SPI_ReadWriteByte((uint8_t)((Dst_Addr)>>24)); 
  #endif
  SPI_ReadWriteByte((uint8_t)((Dst_Addr)>>16));     //发送24bit地址    
  SPI_ReadWriteByte((uint8_t)((Dst_Addr)>>8));   
  SPI_ReadWriteByte((uint8_t)Dst_Addr);  
  W25QXX_CS_H;                                  //取消片选     	      
  W25QXX_Wait_Busy();                           //等待擦除完成
}
 
/********************************************************************************
//等待空闲
*******************************************************************************/
void W25QXX_Wait_Busy(void)   
{   
  while((W25QXX_Read_SR()&0x01)==0x01);   // 等待BUSY位清空
}
 
/********************************************************************************
//进入掉电模式
*******************************************************************************/
void W25QXX_PowerDown(void)   
{ 
  uint16_t Time_i=0xffff;
	
  W25QXX_CS_L;                            //使能器件   
  SPI_ReadWriteByte(W25X_PowerDown);   //发送掉电命令  
  W25QXX_CS_H;                          //取消片选     	      
  while(Time_i--);                      //等待TPD  
}  
 
/********************************************************************************
//唤醒
*******************************************************************************/
void W25QXX_WAKEUP(void)   
{  
  uint16_t Time_i=0xffff;
  W25QXX_CS_L;                            //使能器件   
  SPI_ReadWriteByte(W25X_ReleasePowerDown);   //  send W25X_PowerDown command 0xAB    
  W25QXX_CS_H;                            //取消片选     	      
  while(Time_i--);                               //等待TRES1
}

W25Qxx.h

#ifndef W25QXX__H
#define W25QXX__H

#include "spi.h"

#define W25Q80 	0XEF13 	
#define W25Q16 	0XEF14
#define W25Q32 	0XEF15
#define W25Q64 	0XEF16
#define W25Q128	0XEF17
#define W25Q256 0XEF18

#define ENABLE_W25Q256 1        //要使用W25Q256的32MB空间时，设置1，否则为0

//SPI片选
#define W25QXX_CS_H     HAL_GPIO_WritePin(SPI_CS_GPIO_Port,SPI_CS_Pin,GPIO_PIN_SET)
#define W25QXX_CS_L     HAL_GPIO_WritePin(SPI_CS_GPIO_Port,SPI_CS_Pin,GPIO_PIN_RESET)

//W25Q256
//4Kbytes为一个扇区
//16个扇区为一个Block
//容量32M字节，共有512个Block,8192个Sector
#define W25QXX_FLASH_SIZE             (uint32_t)(32*1024*1024)
#define W25QXX_SECTOR_SIZE            (4096u)   
#define W25QXX_SECTOR_NUMBER          (8192u)

//指令表
#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      0x09
#define W25X_Enable_Rest        0x66
#define W25X_Rest_Device        0x99
#define W25X_Enter_4_Addres     0xb7
#define W25X_Read_4_Addres      0x13
#define W25X_Write_4_Addres     0x02
#define W25X_Exit_4_Addres  	0xe9

int W25QXX_Init(void);
uint16_t W25QXX_ReadID(void);                                                   //读取FLASH ID
uint8_t W25QXX_Read_SR(void);        		                                //读取状态寄存器 
void W25QXX_Write_SR(uint8_t sr);  			                        //写状态寄存器
void W25QXX_Write_Enable(void);  		                                //写使能 
void W25QXX_Write_Disable(void);		                                //写保护
void W25QXX_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint32_t NumByteToWrite);
void W25QXX_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint32_t NumByteToRead);    //读取flash
void W25QXX_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint32_t NumByteToWrite); //写入flash
void W25QXX_Erase_Chip(void);    	  	                                //整片擦除
void W25QXX_Erase_Sector(uint32_t Dst_Addr);                                    //扇区擦除
void W25QXX_Wait_Busy(void);           	                                        //等待空闲
void W25QXX_PowerDown(void);        	                                        //进入掉电模式
void W25QXX_WAKEUP(void);				                        //唤醒
void W25XX_Reset_With_Soft(void);                                               //软件复位W25qXX
#endif

_白+黑_
关注
  • 9
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
STM32H7 OCTOSPI驱动W25qxx （可开启内存映射，程序可在w25qxx学习内运行）
01-21
1.使用时钟源为8Mhz有源晶振（根据自己实际情况修改主频和OCTOSPI时钟频率） 2.例子芯片为STM32H7B0VBT6，w25q128 3.内容亲测有效
STM32cubeMX配置F103的硬件SPI读写W25QXX的FLASH
02-29
（免费）STM32cubeMX配置F103的硬件SPI读写W25Q128的FLASH
W25Q64_FLASH存储器芯片驱动代码(SPI硬件+SPI模拟时序).zip
06-07
这是STM32F103读写华邦W25Q64 FLASH存储器的完整驱动代码，资料包里包含了SPI硬件时序和SPI模拟时序两个工程。实现对W25Q64读写。
STM32—cubeMX+HAL库的SPI接口使用
热门推荐
夜风的博客
01-09 10万+
摘要：  本文主要介绍STM32的SPI接口、cubeMX软件配置SPI接口和分析SPI相关代码。 STM32之SPI简介： （1）SPI协议【Serial Peripheral Interface】    串行外围设备接口，是一种高速全双工的通信总线。主要用在MCU与FLASH\ADC\LCD等模块之间的通信。   （2）SPI信号线        SPI 共包含 4 条总线。 ...
基于STM32实现W25Q16读写操作（spi）
weixin_46155589的博客
12-20 6861
在之前我们学习了flash闪存，这个更多的是内部数据存储，容量也是会比较小。这次我们来学习一下更多的存储单元w25q16，顺便了解spi———串行外围设备接口。在我们的核心板子上基本都会有这么一块芯片，只是有的容量会计较大，大家可以查看板子的原理图，如图所示：有的板子可能是w25q32或者其他，后面的数字代表的是容量，用法都是一样的，从图中或者产品手册我们可以看到芯片是spi协议通信的。串行外设接口 (SPI) 可与外部器件进行半双工/全双工的同步串行通信。
stm32 操作W25Q256 W25Q16 spi flash
Car12
07-27 5942
stm32 操作W25Q256 W25Q16 spi flash
stm32 W25QXX系列驱动 W25Q80 W25Q16 W25Q32 W25Q64 W25Q128 W25Q256
qq_30551297的博客
05-03 3173
W25QXX系列驱动，支持W25Q80,W25Q32,W25Q128,W25Q256,W25Q64,W25Q16,详细中文注释
STM32 + SPI + W25Qxx 外部 FLASH（掉电保存）
m0_52864526的博客
10-08 1597
W25Q16 -------------16M比特 (bit) 2M字节（byte）W25Q32 --------------32M比特 (bit) 4M字节（byte）W25Q64 --------------64M比特 (bit) 8M字节（byte）W25Q128-------------128M比特 (bit) /16M字节（byte）
STM8S005K6与W25Qxx系列Flash的硬件SPI代码
01-26
基于IAR STM8 2.10开发环境，STM8S005K6单片机，采用硬件SPI通信，能读写华邦W25Qxx系列Flash，包含读、写、擦除扇区、擦除块等操作，已测试成功，含完整工程文件。
w25q16/w25x16驱动代码，使用cube库编写，stm32f103测试
02-25
w25q16/w25x16驱动代码，使用stm32的cube库编写，stm32f103测试。完整的工程文档，包含从cube到keil5的源代码完整工程。
W25qxx(STM32 SPI HAL库).rar
06-20
实现对W25Q64/128/512等芯片的驱动，接口标准,实现对存储芯片的调用及管理，擦除，读写等功能。
W25QXX_spiflash_w25q128_w25qxx_
10-01
通过stm32单片机的spi实现flash的读写
STM32F030 HAL库硬件SPI操作W25Q16存储芯片（一）
billjiang2008的专栏
09-29 2740
STM32F030 HAL库硬件SPI操作W25Q16存储芯片
SPI专题（一）----STM32驱动FLASH(W25Q128)
小白来拓荒
06-19 4万+
1、硬件连接 W25Q128 将 16M 的容量分为 256 个块（Block），每个块大小为 64K 字节，每个块又分为 16个扇区（Sector），每个扇区 4K 个字节。 W25Q64 的最少擦除单位为一个扇区，也就是每次必须擦除 4K 个字节。操作需要给 W25Q64 开辟一个至少 4K 的缓存区，对 SRAM 要求比较高，要求芯片必须有 4K 以上 SRAM 才能很好的操作。 ...
STM32快速入门（串口传输之USART）
m0_52566365的博客
05-08 1343
STM32实现USART串口传输，记录了自己学习时的许多细节。
stm32 硬I2C AHT10 驱动
最新发布
zb313982521的博客
05-17 167
3.使用HAL_I2C_Master_Receive 读取寄存器 HAL_I2C_Master_Receive(&hi2c1, AHT10_ADRESS, rawBuff, 6, 0xff);在stm32中 使用 HAL_I2C_Master_Transmit(&hi2c1, AHT10_ADRESS, INIT_CMD, 3, 0xffff);在stm32中 使用 HAL_I2C_Master_Receive(&hi2c1, AHT10_ADRESS, rawBuff, 6, 0xff);
物联网应用开发--STM32+ESP8266与新大陆云平台通信（下行控制蜂鸣器、LED）
面包板扎的专栏
05-14 1208
1、掌握云平台执行器的创建2、熟悉STM32 与ESP8266模块之间的通信3、具体实现目标：（1）创建5个执行器：蜂鸣器，LED1，LED2，ED3，LED4;（2）执行器能对应控制开发板的蜂鸣器和LED。项目创建详细步骤参考：https://blog.csdn.net/luojuan198780/article/details/138766783项目整体：创建5个执行器1.1 执行器之蜂鸣器设置1.2 执行器之LED设置。4个LED配置除了名称其它都一样开发板P7四个跳键帽接法如下图：说明：单片机
stm32 spi写w25qxx和rs485产生冲突
09-07
当STM32的SPI与W25QXX和RS485同时使用时，可能会出现冲突的原因是由于SPI接口的共享问题。SPI是一种用于串行通信的接口，它允许多个设备通过单条总线进行通信。但是，在同时使用SPI接口与W25QXX和RS485时，需要考虑...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值