spi flash驱动

最新推荐文章于 2024-06-27 02:22:12 发布
最新推荐文章于 2024-06-27 02:22:12 发布
阅读量825 收藏
点赞数 1
分类专栏： 嵌入式软件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liupeng08304/article/details/105786371
版权

接口：

//擦除FLASH指定扇区
extern void SPI_Erase_Sector(uint32_t addr);

//擦除FLASH指定Block32
extern void SPI_Erase_Block32(uint32_t addr);

//擦除FLASH指定Block64
extern void SPI_Erase_Block64(uint32_t addr);

//spi_FLash初始化
extern void Spi_Flash_init(void);

//读取FLASH的内容
extern void SPI_Read_Data(uint32_t addr,uint8_t *readBuff,uint32_t numByteToRead);

//连续写入多字节：不用考虑是否达到边界的问题
extern void SPI_Write_Datas(uint32_t WriteAddr ,uint8_t *writeBuff,uint32_t numByteToWrite);

//FLASH进入deep_power_down模式
extern void SPI_EnterDeepPowerDownMode(void);

//FLASH进入deep_power_down模式
extern void SPI_ExitDeepPowerDownMode(void);


extern void spiReadWrtTest(void);

.c


#ifndef LIB_DRIVER_EX_FLASH
#define LIB_DRIVER_EX_FLASH
#include "stm32l1xx_hal.h"
#include "Driver_bord.h"
#include "Driver_exFlash.h"
#include "Driver_configer.h"
#include "string.h"
#endif

#define SPI_MOSI_PIN      			GPIO_PIN_15        	//掉电保持Flash片选引脚号
#define SPI_MISO_PIN      			GPIO_PIN_13        	//掉电保持Flash片选引脚号
#define SPI_SCK_PIN       			GPIO_PIN_14        	//掉电保持Flash片选引脚号
#define SPI_NSS_PIN       			GPIO_PIN_12        	//掉电保持Flash片选引脚号

#define SPI_MOSI_GPIO_PORT          GPIOB   			//
#define SPI_MISO_GPIO_PORT          GPIOB   			//
#define SPI_SCK_GPIO_PORT          	GPIOB   			//
#define SPI_NSS_GPIO_PORT          	GPIOB   			//

#define SOFTWARE_SPI_MOSI_SET()  	HAL_GPIO_WritePin(SPI_MOSI_GPIO_PORT, SPI_MOSI_PIN, GPIO_PIN_SET)  
#define SOFTWARE_SPI_MOSI_CLR()  	HAL_GPIO_WritePin(SPI_MOSI_GPIO_PORT, SPI_MOSI_PIN, GPIO_PIN_RESET)  
#define SOFTWARE_SPI_SCLK_SET()   	HAL_GPIO_WritePin(SPI_SCK_GPIO_PORT, SPI_SCK_PIN, GPIO_PIN_SET)  
#define SOFTWARE_SPI_SCLK_CLR()   	HAL_GPIO_WritePin(SPI_SCK_GPIO_PORT, SPI_SCK_PIN, GPIO_PIN_RESET)  
#define SOFTWARE_SPI_Read()  		HAL_GPIO_ReadPin(SPI_MISO_GPIO_PORT, SPI_MISO_PIN) 
#define SPI_NSS_H   HAL_GPIO_WritePin(SPI_NSS_GPIO_PORT, SPI_NSS_PIN, GPIO_PIN_SET)  
#define SPI_NSS_L   HAL_GPIO_WritePin(SPI_NSS_GPIO_PORT, SPI_NSS_PIN, GPIO_PIN_RESET)


//
// Function name  ：	Spi_Flash_init
// Function capacity  ：	spi_FLash初始化
// Parameter declare  ：
// parameter 1： 	 选择的模式，0-低速模式，1-高速模式
//	......
// Return value   ： void
// Designed idea  ： 
// Author         ：	zhangjun
// Creation date： 2016.7.1
//
void Spi_Flash_init(void)   
{
	GPIO_InitTypeDef GPIO_InitStruct;
	
    GPIO_InitStruct.Pin = SPI_NSS_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(SPI_NSS_GPIO_PORT, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = SPI_SCK_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(SPI_MISO_GPIO_PORT, &GPIO_InitStruct);	

    GPIO_InitStruct.Pin = SPI_MOSI_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(SPI_MOSI_GPIO_PORT, &GPIO_InitStruct);
	
    GPIO_InitStruct.Pin = SPI_MISO_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
	GPIO_InitStruct.Pull = GPIO_PULLUP;
    HAL_GPIO_Init(SPI_NSS_GPIO_PORT, &GPIO_InitStruct); 	
}

//
// Function name  ：	SPI_2_Rx
// Function capacity  ：	SPI2串口接收数据   
// Parameter declare  ：   void
//	......
// Return value   ： 读取的数据
// Designed idea  ： 防止进入死循环，一直等待接收数据
// Author         ：	zhangjun
// Creation date： 2016.7.1
//  

void software_spi00_send_dat(unsigned char dat)
{
    unsigned char temp;
	

	temp = dat;

	SOFTWARE_SPI_SCLK_CLR();
	if(temp&0x80)			SOFTWARE_SPI_MOSI_SET();
	else					SOFTWARE_SPI_MOSI_CLR();
	SOFTWARE_SPI_SCLK_SET();

	SOFTWARE_SPI_SCLK_CLR();
	if(temp&0x40)			SOFTWARE_SPI_MOSI_SET();
	else					SOFTWARE_SPI_MOSI_CLR();
	SOFTWARE_SPI_SCLK_SET();

	SOFTWARE_SPI_SCLK_CLR();
	if(temp&0x20)			SOFTWARE_SPI_MOSI_SET();
	else					SOFTWARE_SPI_MOSI_CLR();
	SOFTWARE_SPI_SCLK_SET();

	SOFTWARE_SPI_SCLK_CLR();
	if(temp&0x10)			SOFTWARE_SPI_MOSI_SET();
	else					SOFTWARE_SPI_MOSI_CLR();
	SOFTWARE_SPI_SCLK_SET();

	SOFTWARE_SPI_SCLK_CLR();
	if(temp&0x08)			SOFTWARE_SPI_MOSI_SET();
	else					SOFTWARE_SPI_MOSI_CLR();
	SOFTWARE_SPI_SCLK_SET();

	SOFTWARE_SPI_SCLK_CLR();
	if(temp&0x04)			SOFTWARE_SPI_MOSI_SET();
	else					SOFTWARE_SPI_MOSI_CLR();
	SOFTWARE_SPI_SCLK_SET();

	SOFTWARE_SPI_SCLK_CLR();
	if(temp&0x02)			SOFTWARE_SPI_MOSI_SET();
	else					SOFTWARE_SPI_MOSI_CLR();
	SOFTWARE_SPI_SCLK_SET();

	SOFTWARE_SPI_SCLK_CLR();
	if(temp&0x01)			SOFTWARE_SPI_MOSI_SET();
	else					SOFTWARE_SPI_MOSI_CLR();
    SOFTWARE_SPI_SCLK_SET();
	
    SOFTWARE_SPI_SCLK_CLR();//end
}

void software_spi00_send_buf(unsigned char *dat,unsigned int len)
{
    unsigned int i;
    unsigned char temp;
	
    for (i=0; i<len; i++)
    {
        temp = dat[i];

        SOFTWARE_SPI_SCLK_CLR();
        if(temp&0x80)			SOFTWARE_SPI_MOSI_SET();
        else					SOFTWARE_SPI_MOSI_CLR();
        SOFTWARE_SPI_SCLK_SET();

        SOFTWARE_SPI_SCLK_CLR();
        if(temp&0x40)			SOFTWARE_SPI_MOSI_SET();
        else					SOFTWARE_SPI_MOSI_CLR();
        SOFTWARE_SPI_SCLK_SET();

        SOFTWARE_SPI_SCLK_CLR();
        if(temp&0x20)			SOFTWARE_SPI_MOSI_SET();
        else					SOFTWARE_SPI_MOSI_CLR();
        SOFTWARE_SPI_SCLK_SET();

        SOFTWARE_SPI_SCLK_CLR();
        if(temp&0x10)			SOFTWARE_SPI_MOSI_SET();
        else					SOFTWARE_SPI_MOSI_CLR();
        SOFTWARE_SPI_SCLK_SET();

        SOFTWARE_SPI_SCLK_CLR();
        if(temp&0x08)			SOFTWARE_SPI_MOSI_SET();
        else					SOFTWARE_SPI_MOSI_CLR();
        SOFTWARE_SPI_SCLK_SET();

        SOFTWARE_SPI_SCLK_CLR();
        if(temp&0x04)			SOFTWARE_SPI_MOSI_SET();
        else					SOFTWARE_SPI_MOSI_CLR();
        SOFTWARE_SPI_SCLK_SET();

        SOFTWARE_SPI_SCLK_CLR();
        if(temp&0x02)			SOFTWARE_SPI_MOSI_SET();
        else					SOFTWARE_SPI_MOSI_CLR();
        SOFTWARE_SPI_SCLK_SET();

        SOFTWARE_SPI_SCLK_CLR();
        if(temp&0x01)			SOFTWARE_SPI_MOSI_SET();
        else					SOFTWARE_SPI_MOSI_CLR();
        SOFTWARE_SPI_SCLK_SET();
    }
	
    SOFTWARE_SPI_SCLK_CLR();//end
}

unsigned char software_spi00_receiver_dat(void)
{
    unsigned char dat=0;

    SOFTWARE_SPI_SCLK_SET();
    if(SOFTWARE_SPI_Read())		dat|=0x80;
    SOFTWARE_SPI_SCLK_CLR();

    SOFTWARE_SPI_SCLK_SET();
    if(SOFTWARE_SPI_Read())		dat|=0x40;
    SOFTWARE_SPI_SCLK_CLR();

    SOFTWARE_SPI_SCLK_SET();
    if(SOFTWARE_SPI_Read())		dat|=0x20;
    SOFTWARE_SPI_SCLK_CLR();

    SOFTWARE_SPI_SCLK_SET();
    if(SOFTWARE_SPI_Read())		dat|=0x10;
    SOFTWARE_SPI_SCLK_CLR();

    SOFTWARE_SPI_SCLK_SET();
    if(SOFTWARE_SPI_Read())		dat|=0x08;
    SOFTWARE_SPI_SCLK_CLR();

    SOFTWARE_SPI_SCLK_SET();
    if(SOFTWARE_SPI_Read())		dat|=0x04;
    SOFTWARE_SPI_SCLK_CLR();

    SOFTWARE_SPI_SCLK_SET();
    if(SOFTWARE_SPI_Read())		dat|=0x02;
    SOFTWARE_SPI_SCLK_CLR();

    SOFTWARE_SPI_SCLK_SET();
    if(SOFTWARE_SPI_Read())		dat|=0x01;
    SOFTWARE_SPI_SCLK_CLR();

    SOFTWARE_SPI_SCLK_CLR();//end
    return dat;
}

void  software_spi00_receiver_buf(uint8_t *buf,uint32_t len)
{
    uint32_t i;
    for (i=0; i<len; i++)
    {
        buf[i] = software_spi00_receiver_dat();
    }

}

//读取ID号
uint32_t SPI_Read_ID(void)
{
    uint32_t flash_id;

    //片选使能
    SPI_NSS_L;
	
    software_spi00_send_dat(READ_JEDEC_ID);

    flash_id = software_spi00_receiver_dat();
    flash_id <<= 8;
    flash_id |= software_spi00_receiver_dat(); 
    flash_id <<= 8;
    flash_id |= software_spi00_receiver_dat(); 

    SPI_NSS_H;

    return flash_id;
}

//FLASH写入使能
void SPI_Write_Enable(void)
{
        //片选使能
    SPI_NSS_L;
	
    software_spi00_send_dat(WRITE_ENABLE);   
	
    SPI_NSS_H;  
}



//擦除FLASH指定扇区
void SPI_Erase_Sector(uint32_t addr)
{   
	SPI_Write_Enable();	//片选使能
	
	SPI_NSS_L;
	
	software_spi00_send_dat(ERASE_SECTOR);
	software_spi00_send_dat((addr>>16)&0xff);
	software_spi00_send_dat((addr>>8)&0xff); 
	software_spi00_send_dat(addr&0xff); 

	SPI_NSS_H;  
	
	SPI_WaitForWriteEnd();	

}

//擦除FLASH指定Block32
void SPI_Erase_Block32(uint32_t addr)
{   
	SPI_Write_Enable();
		//片选使能
	SPI_NSS_L;
	
	software_spi00_send_dat(ERASE_BLOCK_32);
	software_spi00_send_dat((addr>>16)&0xff);
	software_spi00_send_dat((addr>>8)&0xff); 
	software_spi00_send_dat(addr&0xff); 

	SPI_NSS_H;  
	
	SPI_WaitForWriteEnd();		

}

//擦除FLASH指定Block64
void SPI_Erase_Block64(uint32_t addr)
{   
	SPI_Write_Enable();
		//片选使能
	SPI_NSS_L;
	
	software_spi00_send_dat(ERASE_BLOCK_64);
	software_spi00_send_dat((addr>>16)&0xff);
	software_spi00_send_dat((addr>>8)&0xff); 
	software_spi00_send_dat(addr&0xff); 

	SPI_NSS_H;  
	
	SPI_WaitForWriteEnd();	
}



//读取FLASH的内容
void SPI_Read_Data(uint32_t addr,uint8_t *readBuff,uint32_t numByteToRead)
{
	SPI_Write_Enable();
	
	SPI_NSS_L;
	
	software_spi00_send_dat(READ_DATA);
	software_spi00_send_dat((addr>>16)&0xff);
	software_spi00_send_dat((addr>>8)&0xff); 
	software_spi00_send_dat(addr&0xff); 
	
	software_spi00_receiver_buf(readBuff,numByteToRead);

	SPI_NSS_H;  
	
	SPI_WaitForWriteEnd();	
}





//向FLASH写入内容
void SPI_Write_Data(uint32_t addr,uint8_t *writeBuff,uint32_t numByteToWrite)
{
	SPI_Write_Enable();
	
	SPI_NSS_L;
	
	software_spi00_send_dat(WRITE_DATA);
	software_spi00_send_dat((addr>>16)&0xff);
	software_spi00_send_dat((addr>>8)&0xff); 
	software_spi00_send_dat(addr&0xff); 
	
	software_spi00_send_buf(writeBuff,numByteToWrite);

	SPI_NSS_H;  
	
	SPI_WaitForWriteEnd();	
}


//连续写入多字节：不用考虑是否达到边界的问题，写入字节数也没有限制（当然要小于FLASH容量）
void SPI_Write_Datas(uint32_t WriteAddr ,uint8_t *writeBuff,uint32_t numByteToWrite)
{
	unsigned char NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
	
    SPI_Write_Enable();

    SPI_NSS_L;        //片选使能		
	
	Addr = WriteAddr  % FLASH_PAGE_MAX;
	count = FLASH_PAGE_MAX - Addr;					//差多少可以对齐数据页地址
	
	NumOfPage = numByteToWrite / FLASH_PAGE_MAX;	/*计算出要写多少整数页*/
	
	NumOfSingle = numByteToWrite % FLASH_PAGE_MAX;	/*mod 运算求余，计算出剩余不满一页的字节数*/
	
	if (Addr == 0)		/* Addr=0,则 WriteAddr 刚好按页对齐 aligned */
	{
		if(NumOfPage == 0)
		{
			SPI_Write_Data( WriteAddr,writeBuff,numByteToWrite);
		}
		else
		{
			while(NumOfPage--)										/*先把整数页都写了*/
			{
				SPI_Write_Data( WriteAddr,writeBuff,FLASH_PAGE_MAX); 
				writeBuff = writeBuff + FLASH_PAGE_MAX; 
				WriteAddr = WriteAddr + FLASH_PAGE_MAX; 		
			}
			SPI_Write_Data( WriteAddr,writeBuff,NumOfSingle);		/*若有多余的不满一页的数据，把它写完*/
		}
	}
	else		/* 若地址与 SPI_FLASH_PageSize 不对齐 */
	{
		if(NumOfPage == 0)
		{
			if(NumOfSingle > count)				/*当前页剩余的 count 个位置比 NumOfSingle 小，一页写不完*/
			{
				temp = NumOfSingle - count;
				SPI_Write_Data( WriteAddr,writeBuff,count);				/*先写满当前页*/
				WriteAddr += count;
				writeBuff += count;
				
				SPI_Write_Data( WriteAddr,writeBuff,temp);			
			}
			else								/*当前页剩余的 count 个位置能写完 NumOfSingle 个数据*/
			{
				SPI_Write_Data( WriteAddr,writeBuff,numByteToWrite);
			}
		}
		else									/* numByteToWrite > FLASH_PAGE_MAX */
		{
			numByteToWrite = numByteToWrite - count;			
			NumOfPage = numByteToWrite / FLASH_PAGE_MAX;	/*计算出要写多少整数页*/			
			NumOfSingle = numByteToWrite % FLASH_PAGE_MAX;	/*mod 运算求余，计算出剩余不满一页的字节数*/			
			
			SPI_Write_Data( WriteAddr,writeBuff,count);
			WriteAddr += count;
			writeBuff += count;			
					
			while(NumOfPage--)										/*先把整数页都写了*/
			{
				SPI_Write_Data( WriteAddr,writeBuff,FLASH_PAGE_MAX); 
				writeBuff = writeBuff + FLASH_PAGE_MAX; 
				WriteAddr = WriteAddr + FLASH_PAGE_MAX; 		
			}
			if(NumOfSingle != 0)
			{
				SPI_Write_Data( WriteAddr,writeBuff,NumOfSingle);		/*若有多余的不满一页的数据，把它写完*/
			}
		}		
	}
	
    SPI_NSS_H;	
	
}


//等待FLASH内部时序操作完成
void SPI_WaitForWriteEnd(void)
{
    uint8_t status_reg = 0;

    //片选使能
    SPI_NSS_L;

    software_spi00_send_dat(READ_STATUS);

    do
    {   
		status_reg = software_spi00_receiver_dat();
    }
    while((status_reg & 0x01) == 1);

    SPI_NSS_H;  
}

FLASH进入deep_power_down模式
//void SPI_EnterDeepPowerDownMode(void)
//{
//	SPI_Write_Enable();
//	
//    //片选使能
//    SPI_NSS_L;

//    software_spi00_send_dat(DEEP_POWER_DOWN);

//    SPI_NSS_H; 
//}

FLASH进入deep_power_down模式
//void SPI_ExitDeepPowerDownMode(void)
//{
//	SPI_Write_Enable();
//	
//    //片选使能
//    SPI_NSS_L;

//    software_spi00_send_dat(EXIT_DEEP_POWER_DOWN);

//    SPI_NSS_H; 

//	SPI_WaitForWriteEnd();		
//}


//#define SPI_flash_Test 1

//#ifdef SPI_flash_Test
//unsigned char spiTestBuf[1500];

//void spiReadWrtTest(void)
//{
//	unsigned short i;
//	
//	SPI_Read_Data(1024,spiTestBuf,sizeof(spiTestBuf));	
//	
//	for(i=0;i<1;i++)
//	{
//		SPI_Erase_Block32(0 + i*64*1024);
//	}
//	
//	memset(spiTestBuf,0x55,sizeof(spiTestBuf));
//	
//	SPI_Write_Datas(1024,spiTestBuf,sizeof(spiTestBuf));
//	memset(spiTestBuf,0,sizeof(spiTestBuf));
//	SPI_Read_Data(1024,spiTestBuf,sizeof(spiTestBuf));
//	
//	SPI_Write_Datas(2000,spiTestBuf,sizeof(spiTestBuf));\
//	memset(spiTestBuf,0,sizeof(spiTestBuf));
//	SPI_Read_Data(2000,spiTestBuf,sizeof(spiTestBuf));	
//	
//	for(i=0;i<1;i++)
//	{
//		SPI_Erase_Block32(0 + i*64*1024);
//	}

//	memset(spiTestBuf,0xaa,sizeof(spiTestBuf));
//	SPI_Write_Datas(1024,spiTestBuf,sizeof(spiTestBuf));
//	SPI_Read_Data(1024,spiTestBuf,sizeof(spiTestBuf));	
//	
//	SPI_Write_Datas(2000,spiTestBuf,sizeof(spiTestBuf));
//	SPI_Read_Data(2000,spiTestBuf,sizeof(spiTestBuf));	
//}
//#endif

.h
···
#ifndef DRIVER_EX_FLASH_H
#define DRIVER_EX_FLASH_H

#endif

#include “stdint.h”

#define DUMMY 0x00
#define READ_JEDEC_ID 0x9f
#define ERASE_SECTOR 0x20
#define ERASE_BLOCK_32 0x52
#define ERASE_BLOCK_64 0xd8
#define READ_STATUS 0x05
#define READ_DATA 0x03
#define WRITE_ENABLE 0x06
#define WRITE_DATA 0x02

#define DEEP_POWER_DOWN 0xB9
#define EXIT_DEEP_POWER_DOWN 0xAB

#define FLASH_PAGE_MAX 256

#ifdef LIB_DRIVER_EX_FLASH

void SPI_WaitForWriteEnd(void);

#else

//擦除FLASH指定扇区
extern void SPI_Erase_Sector(uint32_t addr);

//擦除FLASH指定Block32
extern void SPI_Erase_Block32(uint32_t addr);

//擦除FLASH指定Block64
extern void SPI_Erase_Block64(uint32_t addr);

//spi_FLash初始化
extern void Spi_Flash_init(void);

//读取FLASH的内容
extern void SPI_Read_Data(uint32_t addr,uint8_t *readBuff,uint32_t numByteToRead);

//连续写入多字节：不用考虑是否达到边界的问题
extern void SPI_Write_Datas(uint32_t WriteAddr ,uint8_t *writeBuff,uint32_t numByteToWrite);

//FLASH进入deep_power_down模式
extern void SPI_EnterDeepPowerDownMode(void);

//FLASH进入deep_power_down模式
extern void SPI_ExitDeepPowerDownMode(void);

extern void spiReadWrtTest(void);

#endif

···

liupeng08304
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SPI Flash 通用驱动程序（SFUD）
07-29
SFUD 是一款开源的串行 SPI Flash 通用驱动库。由于现有市面的串行 Flash 种类居多，各个 Flash 的规格及命令存在差异， SFUD 就是为了解决这些 Flash 的差异现状而设计，让我们的产品能够支持不同品牌及规格的 Flash，提高了涉及到 Flash 功能的软件的可重用性及可扩展性，同时也可以规避 Flash 缺货或停产给产品所带来的风险。最新版本见：https://github.com/armink/SFUD
SPI_FLASH驱动
tpmamba的博客
01-27 1491
SPI_FLASH驱动及调试 (1)编写spi_flash驱动 参考文件：mtdram.c (drivers\mtd\devices)和m25p80.c (drivers\mtd\devices) 编写步骤： 与前面spi_oled_drv类似，首先构建一个spi_driver结构体(注意其成员.name应与单板信息中的一致，即该驱动与单板信息文件配套使用)，并注册； pro
STM32 SPI实战篇：驱动W25Q64 Flash存储器的技巧与方法
最新发布
weixin_66608063的博客
06-27 664
在嵌入式系统开发中，非易失性存储是必不可少的一部分。W25Q64作为SPI Flash存储器的一种，以其较高的存储密度和擦写次数受到广泛应用。本文将深入探讨STM32通过SPI驱动W25Q64的实战技巧和方法，包括硬件连接、SPI配置、读写操作，以及实际代码示例。
Linux下的SPI FLASH驱动
weixin_45090728的博客
10-03 628
spi flash驱动框架
spiflash 驱动代码
06-16
完整的spiflash驱动代码，架构扩展性良好，兼容性广，支持四线串行闪存QPI模式。 先要调用init函数初始化，才能调用读写等函数。
spiflash驱动w25qxx.zip
04-20
本资源为w25qxx系列flash的spi驱动代码 包含spi.h和spi.c和w25qxx.h和w25qxx.c四个驱动文件和头文件
STM32之SPI驱动外部Flash
Andy001847的专栏
09-22 2218
MCU为STM32F030C8T6，Nor Flash为IS25LQ010B。spi.h源代码#ifndef __spi_H #define __spi_H#ifdef __cplusplus extern "C" { #endif/* Includes ------------------------------------------------------------------*/ #inc
SpiFlash驱动代码
07-27
本篇文章将深入探讨SPI Flash驱动代码的相关知识点。 一、SPI总线协议 SPI总线是一种同步串行通信接口，由主机（Master）控制数据传输，从机（Slave）接收或发送数据。SPI接口通常包括四条信号线：主时钟（SCK）、...
spi nand flash.zip
03-18
spi接口的nand flash。程序是基于GD5F1GQ4xExIG的协议编写的，完成了读寄存器，写寄存器，擦除，读PAGE，写PAGE，读cache，写cahche等接口。不包括坏块管理和空间管理。
基于linux2.6.33的spi flash 驱动移植总结
08-18
### 基于Linux 2.6.33的SPI Flash驱动移植总结 #### SPI驱动架构概述 在基于Linux 2.6.33的SPI Flash驱动移植过程中，主要涉及到了三个关键组件：SPI主机驱动（dm644x上的SPI功能模块驱动）、SPI Flash芯片驱动...
spiflash w25q128驱动函数
12-12
spiflash w25q128驱动函数 包含block擦数，sector擦数 页写 多页写 页读 多页读函数 已调试通过
W25x系列Flash芯片驱动程序(STM32单片机的SPI调试通过)
07-10
华邦W25x系列Flash存储芯片驱动程序，我用stm32单片机的SPI功能已经调试成功，现将该驱动程序上传，以便大家一起互相学习交流，QQ1342456650.
SPI专题（二）——STM32驱动FLASH(W25Q64)
热门推荐
霁风AI
08-31 3万+
1.硬件连接 W25Q64 将 8M 的容量分为 128 个块（Block），每个块大小为 64K 字节，每个块又分为 16个扇区（Sector），每个扇区 4K 个字节。 W25Q64 的最少擦除单位为一个扇区，也就是每次必须擦除 4K 个字节。操作需要给 W25Q64 开辟一个至少 4K 的缓存区，对 SRAM 要求比较高，要求芯片必须有 4K 以上 SRAM 才能很好的操作。 W25
SPI FLASH 容量计算
zouyibo1988的专栏
06-20 3751
//0x9f 的ID2  计算FLASH容量 u32  CalcFlashCapacity(u8 CapcaityID, u8* u8Unit) {     u8 i = 0;     u32 u32Result = 2     if (u32Result     {         *u8Unit = 'B';     }     else     {    
基于ZYNQ PS-SPI的Flash驱动开发
北京菜刀
03-05 1666
本文使用PS-SPI实现Flash读写，PS-SPI的基础资料参考Xilinx UG1085的文档说明，其基础使用方法是，配置SPI模式，控制TXFIFO/RXFIFO，ZYNQ的IP自动完成发送TXFIFO数据，接收数据到RXFIFO，FIFO深度为128Byte。本文介绍了使用PS-SPI的Flash开发。
STM32入门教程——驱动SPI Flash的经验分享
03-23 678
**MISO (Master In Slave Out)**: 主设备输入/从设备输出引脚。- **MOSI (Master Out Slave In)**: 主设备输出/从设备输入引脚。- **CS (Chip Select)**: 片选信号引脚，用于启动和结束SPI通信。- **Sector Erase (0x20 - 0x21)**: 扇区擦除。- **Write Disable (0x04)**: 禁止写入操作。- **Write Enable (0x06)**: 使能写入操作。
SPI flash配置
u010448932的博客
09-04 3391
配置表中预先配好了一些，我们用到什么SPI就需要添加相应的spi配置参数 spi flash name jedec_id ext_id block_size chip_size clk chip select 我们在此以W25Q128为例进行说明： 首先是jedec_id           打开数据手册搜索jedec，会发现 JEDEC ID...
linux下spi flash驱动程序,SPI Flash(W25Q16DV) 驱动
weixin_36068140的博客
05-04 1220
大体上可分为以下几个部分：1.注册设备驱动 spi_register_driver2.分配 mtd_info 结构体3.配置 mtd_info 结构体4.注册 mtd_info 结构体构建 spi_driver 并注册static struct spi_driver spi_flash_drv = {.driver = {.name= "spi_flash",.owner= THIS_MODULE...
spi flash驱动代码分析（一）
Jalen_king
07-17 1万+
一、       spi_flash uboot驱动的一个应用实例 1.      spi应用程序在操作之前调用spi_flash_probe去初始化spi_flash 2.      初始化完毕即可读写spi flash void spl_spi_load_image(void) {          //初始化SPI FLASH          flash =spi_flash_p
spi flash驱动读写demo
04-01
作为AI助手，我无法提供具体的代码实现，但我可以为您提供SPI Flash驱动的读写demo的大致思路： 1. 初始化SPI总线和SPI Flash芯片 2. 写入数据到SPI Flash芯片 3. 从SPI Flash芯片中读取数据 4. 擦除SPI Flash芯片中的数据 5. 释放SPI Flash芯片的资源 以下是SPI Flash驱动的读写demo的一般流程： #include <SPI.h> #include "SPIFlash.h" // 定义SPIFlash对象 SPIFlash spi_flash; void setup() { // 初始化SPI总线 SPI.begin(); // 初始化SPIFlash对象 spi_flash.begin(); // 将数据写入SPI Flash芯片 byte data[] = {0x01, 0x02, 0x03, 0x04}; spi_flash.write(0x0000, data, 4); // 从SPI Flash芯片中读取数据 byte read_data[4]; spi_flash.read(0x0000, read_data, 4); // 擦除SPI Flash芯片中的数据 spi_flash.eraseChip(); } void loop() { // 释放SPI Flash芯片的资源 spi_flash.end(); }
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值