收藏
下载资源下载资源 加入VIP,免费下载

AT25M01使用说明 SPI EEPROM STM32.docx

上传人：b****3 文档编号：3842272 上传时间：2022-11-25 格式：DOCX 页数：15 大小：17.58KB
下载 相关 举报
AT25M01使用说明 SPI EEPROM STM32.docx_第1页
第1页 / 共15页
AT25M01使用说明 SPI EEPROM STM32.docx_第2页
第2页 / 共15页
AT25M01使用说明 SPI EEPROM STM32.docx_第3页
第3页 / 共15页
AT25M01使用说明 SPI EEPROM STM32.docx_第4页
第4页 / 共15页
AT25M01使用说明 SPI EEPROM STM32.docx_第5页
第5页 / 共15页
点击查看更多>>
下载资源
资源描述

AT25M01使用说明 SPI EEPROM STM32.docx

《AT25M01使用说明 SPI EEPROM STM32.docx》由会员分享，可在线阅读，更多相关《AT25M01使用说明 SPI EEPROM STM32.docx（15页珍藏版）》请在冰豆网上搜索。

AT25M01使用说明 SPI EEPROM STM32.docx

AT25M01使用说明SPIEEPROMSTM32

1.芯片访问规则符合AT25系列原则，可以找相关的例子，但是25M01目前没有

2.芯片工作原则，不考虑写保护问题，所有操作的第一步都是要发送写允许指令，然后重新片选有效，发送下一步的命令。

注意问题：

SPI的EEPROM的数据输出的原理是，在输入一个字节的同时输出一个字节，没有输入字节，就输出，所以，所谓的读数据，其实质是先发送一个数据，然后在接收一个数据。

操作如下：

（1）寄存器读

1）先片选，在发送写允许指令，片选无效

2）片选，发送读寄存器指令，读寄存器，片选无效

（2）寄存器写

1）先片选，在发送写允许指令，片选无效

2）片选，发送写寄存器指令，写数据，片选无效

（3）写数据

1）先片选，在发送写允许指令，片选无效

2）片选，发送写数据指令，写数据，片选无效

（4）读数据

1）先片选，在发送写允许指令，片选无效

2）片选，发送读数据指令，读数据，片选无效

注意：

STM32的SPI需要，每次都开启

 

voidSPI_EEPROM_Init（void）

{

SPI_InitTypeDefSPI_InitStructure;

GPIO_InitTypeDefGPIO_InitStructure;

/*EnableSPI1andGPIOclocks*/

/*!

SPI_FLASH_SPI_MISO_GPIO,SPI_FLASH_SPI_DETECT_GPIO

andSPI_FLASH_SPI_SCK_GPIOPeriphclockenable*/

RCC_APB2PeriphClockCmd（RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC|RCC_APB2Periph_AFIO,ENABLE）;

/*!

RCC_APB2PeriphClockCmd（RCC_APB2Periph_SPI1,ENABLE）;

/*!

SCK*/

GPIO_InitStructure.GPIO_Pin=GPIO_Pin_5;

GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;

GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;

GPIO_Init（GPIOA,&GPIO_InitStructure）;

/*!

MOSI*/

GPIO_InitStructure.GPIO_Pin=GPIO_Pin_7;

GPIO_Init（GPIOA,&GPIO_InitStructure）;

/*!

MISO*/

GPIO_InitStructure.GPIO_Pin=GPIO_Pin_6;

//GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING;

GPIO_Init（GPIOA,&GPIO_InitStructure）;

//选通采用软件模式-------------------------

/*!

SPI_FLASHCardCSpin*/

GPIO_InitStructure.GPIO_Pin=GPIO_Pin_4;

GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;

GPIO_Init（GPIOA,&GPIO_InitStructure）;//NSS1

GPIO_InitStructure.GPIO_Pin=GPIO_Pin_4;

GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;

GPIO_Init（GPIOC,&GPIO_InitStructure）;//NSS2

/*DeselecttheFLASH:

ChipSelecthigh*/

NSS1_HIGH（）;

NSS1_HIGH（）;

/*SPI1configuration*/

//W25X16:

datainputontheDIOpinissampledontherisingedgeoftheCLK.

//DataontheDOandDIOpinsareclockedoutonthefallingedgeofCLK.

SPI_InitStructure.SPI_Direction=SPI_Direction_2Lines_FullDuplex;

SPI_InitStructure.SPI_Mode=SPI_Mode_Master;

SPI_InitStructure.SPI_DataSize=SPI_DataSize_8b;

//SPI模式3

//SPI_InitStructure.SPI_CPOL=SPI_CPOL_High;

//SPI_InitStructure.SPI_CPHA=SPI_CPHA_2Edge;

//SPI模式0

SPI_InitStructure.SPI_CPOL=SPI_CPOL_Low;

SPI_InitStructure.SPI_CPHA=SPI_CPHA_1Edge;

//软件片选

SPI_InitStructure.SPI_NSS=SPI_NSS_Soft;

//硬件片选

//SPI_InitStructure.SPI_NSS=SPI_NSS_Hard;

SPI_InitStructure.SPI_BaudRatePrescaler=SPI_BaudRatePrescaler_8;//72M/8=9Mhz,供电

SPI_InitStructure.SPI_FirstBit=SPI_FirstBit_MSB;

SPI_InitStructure.SPI_CRCPolynomial=7;

SPI_Init（SPI1,&SPI_InitStructure）;

/*EnableSPI1*/

SPI_Cmd（SPI1,DISABLE）;

}

/*********************************************ENDOFFILE**********************/

voidNSS_CS_ENABLE（uint8_tNSS）

{

if（NSS==1）{NSS1_LOW（）;NSS2_HIGH（）;}

elseif（NSS==2）{NSS2_LOW（）;NSS1_HIGH（）;}

}

voidNSS_CS_DISABLE（）

{

NSS1_HIGH（）;

NSS2_HIGH（）;

}

voidSPI_WREN（uint8_tnss）

{

NSS_CS_ENABLE（nss）;

SPI_WriteByte（WREN）;

NSS_CS_DISABLE（）;

//Delay_ms

（1）;

}

voidSPI_WRDI（uint8_tnss）

{

NSS_CS_ENABLE（nss）;

SPI_WriteByte（WRDI）;

NSS_CS_DISABLE（）;

//Delay_ms

（1）;

}

voidSPI_EEPROM_WRITE_Start（void）

{

SPI_Cmd（SPI1,ENABLE）;

SPI_WREN

（1）;

NSS_CS_ENABLE

（1）;

SPI_WriteByte（WRSR）;

SPI_WriteByte（0X02）;

NSS_CS_DISABLE（）;

SPI_WREN

（2）;

NSS_CS_ENABLE

（2）;

SPI_WriteByte（WRSR）;

SPI_WriteByte（0X02）;

NSS_CS_DISABLE（）;

SPI_Cmd（SPI1,DISABLE）;

}

voidSPI_EEPROM_WRITE_END（void）

{

SPI_Cmd（SPI1,ENABLE）;

SPI_WRDI

（1）;

SPI_WRDI

（2）;

SPI_Cmd（SPI1,DISABLE）;

}

uint8_tSPI_WriteByte（uint8_tdata）

{

/*LoopwhileDRregisterinnotemplty*/

while（SPI_I2S_GetFlagStatus（SPI1,SPI_I2S_FLAG_TXE）==RESET）;

/*SendbytethroughtheSPI1peripheral*/

SPI_I2S_SendData（SPI1,data）;

/*Waittoreceiveabyte*/

while（SPI_I2S_GetFlagStatus（SPI1,SPI_I2S_FLAG_RXNE）==RESET）;

/*ReturnthebytereadfromtheSPIbus*/

returnSPI_I2S_ReceiveData（SPI1）;

}

uint8_tSPI_ReadByte（void）

{

return（SPI_WriteByte（Dummy_Byte））;

//while（SPI_I2S_GetFlagStatus（SPI1,SPI_I2S_FLAG_RXNE）==RESET）;

//returnSPI_I2S_ReceiveData（SPI1）;

}

uint8_tAT25_GetStatus（uint8_tNSS）

{

uint8_ttmp=0;

SPI_WREN（NSS）;

NSS_CS_ENABLE（NSS）;

SPI_WriteByte（RDSR）;

tmp=SPI_ReadByte（）;

NSS_CS_DISABLE（）;

returntmp;

}

voidAT25_WaitReady（uint8_tNSS）

{

while（（0x01&AT25_GetStatus（NSS））!

=0）;

}

/*

单字节操作，读和写

*/

uint8_tAT25_ReadByte（uint32_taddr）

{

uint8_ttmp;

uint8_tnss=1;

if（addr>=（uint32_t）（1024*128*2））

return0;

if（addr>=（uint32_t）（1024*128））

{addr=addr-（uint32_t）（1024*128）;nss=2;}

elsenss=1;

SPI_Cmd（SPI1,ENABLE）;

AT25_WaitReady（nss）;

SPI_WREN（nss）;

NSS_CS_ENABLE（nss）;

SPI_WriteByte（READ）;

SPI_WriteByte（（uint8_t）（（addr&0x010000）>>16））;/*A16*/

SPI_WriteByte（（uint8_t）（（addr&0x00FF00）>>8））;/*A15-A8*/

SPI_WriteByte（（uint8_t）（addr&0x0000FF））;/*A7-A0*/

tmp=SPI_ReadByte（）;

NSS_CS_DISABLE（）;

SPI_Cmd（SPI1,DISABLE）;

returntmp;

}

voidAT25_WriteByte（uint8_tdata,uint32_taddr）

{

uint8_tnss=1;

uint32_ttt=1024*128*2;

if（addr>=tt）

return;

if（addr>=（uint32_t）（1024*128））

{addr=addr-（uint32_t）（1024*128）;nss=2;}

elsenss=1;

SPI_Cmd（SPI1,ENABLE）;

AT25_WaitReady（nss）;

SPI_WREN（nss）;

NSS_CS_ENABLE（nss）;

SPI_WriteByte（WRITE）;

SPI_WriteByte（（uint8_t）（（addr&0x010000）>>16））;/*A16*/

SPI_WriteByte（（uint8_t）（（addr&0x00FF00）>>8））;/*A15-A8*/

SPI_WriteByte（（uint8_t）（addr&0x0000FF））;/*A7-A0*/

SPI_WriteByte（data）;

NSS_CS_DISABLE（）;

SPI_Cmd（SPI1,DISABLE）;

}

////////////多字节操作

/**

*@brief将缓冲区中的数据写到I2CEEPROM中

*@param

*@argpBuffer:

缓冲区指针

*@argWriteAddr:

写地址

*@argNumByteToWrite:

写的字节数

*@retval无

*/

voidSPI_EE_BufferWrite（u8*pBuffer,u32WriteAddr,u16NumByteToWrite,uint8_tNSS）

{

u32NumOfPage=0,NumOfSingle=0,Addr=0,count=0;

Addr=WriteAddr%I2C_PageSize;

count=I2C_PageSize-Addr;

NumOfPage=NumByteToWrite/I2C_PageSize;

NumOfSingle=NumByteToWrite%I2C_PageSize;

/*IfWriteAddrisI2C_PageSizealigned*/

if（Addr==0）

{

/*IfNumByteToWrite

if（NumOfPage==0）

{

SPI_EE_PageWrite（pBuffer,WriteAddr,NumOfSingle,NSS）;

}

/*IfNumByteToWrite>I2C_PageSize*/

else

{

while（NumOfPage--）

{

SPI_EE_PageWrite（pBuffer,WriteAddr,I2C_PageSize,NSS）;

WriteAddr+=I2C_PageSize;

pBuffer+=I2C_PageSize;

}

if（NumOfSingle!

=0）

{

SPI_EE_PageWrite（pBuffer,WriteAddr,NumOfSingle,NSS）;

}

}

}

/*IfWriteAddrisnotI2C_PageSizealigned*/

else

{

/*IfNumByteToWrite

if（NumOfPage==0）

{

SPI_EE_PageWrite（pBuffer,WriteAddr,NumOfSingle,NSS）;

}

/*IfNumByteToWrite>I2C_PageSize*/

else

{

NumByteToWrite-=count;

NumOfPage=NumByteToWrite/I2C_PageSize;

NumOfSingle=NumByteToWrite%I2C_PageSize;

if（count!

=0）

{

SPI_EE_PageWrite（pBuffer,WriteAddr,count,NSS）;

WriteAddr+=count;

pBuffer+=count;

}

while（NumOfPage--）

{

SPI_EE_PageWrite（pBuffer,WriteAddr,I2C_PageSize,NSS）;

WriteAddr+=I2C_PageSize;

pBuffer+=I2C_PageSize;

}

if（NumOfSingle!

=0）

{

SPI_EE_PageWrite（pBuffer,WriteAddr,NumOfSingle,NSS）;

}

}

}

}

/**

*@brief在EEPROM的一个写循环中可以写多个字节，但一次写入的字节数

*不能超过EEPROM页的大小，AT24C02每页有8个字节

*@param

*@argpBuffer:

缓冲区指针

*@argWriteAddr:

写地址

*@argNumByteToWrite:

写的字节数

*@retval无

*/

voidSPI_EE_PageWrite（u8*pBuffer,u32WriteAddr,u16NumByteToWrite,uint8_tNSS）

{

SPI_Cmd（SPI1,ENABLE）;

AT25_WaitReady（NSS）;

SPI_WREN（NSS）;

NSS_CS_ENABLE（NSS）;

SPI_WriteByte（WRITE）;

SPI_WriteByte（（uint8_t）（（WriteAddr&0x010000）>>16））;/*A16*/

SPI_WriteByte（（uint8_t）（（WriteAddr&0x00FF00）>>8））;/*A15-A8*/

SPI_WriteByte（（uint8_t）（WriteAddr&0x0000FF））;/*A7-A0*/

/*Whilethereisdatatobewritten*/

while（NumByteToWrite--）

{

/*Sendthecurrentbyte*/

SPI_WriteByte（*pBuffer）;

/*Pointtothenextbytetobewritten*/

pBuffer++;

}

/*SendSTOPcondition*/

NSS_CS_DISABLE（）;

SPI_Cmd（SPI1,DISABLE）;

}

/**

*@brief从EEPROM里面读取一块数据

*@param

*@argpBuffer:

存放从EEPROM读取的数据的缓冲区指针

*@argWriteAddr:

接收数据的EEPROM的地址

*@argNumByteToWrite:

要从EEPROM读取的字节数

*@retval无

*/

voidSPI_EE_BufferRead（u8*pBuffer,u32ReadAddr,u16NumByteToRead,uint8_tNSS）

{

uint8_tnss=NSS;

SPI_Cmd（SPI1,ENABLE）;

AT25_WaitReady（nss）;

SPI_WREN（NSS）;

NSS_CS_ENABLE（nss）;

SPI_WriteByte（READ）;

SPI_WriteByte（（uint8_t）（（ReadAddr&0x010000）>>16））;/*A16*/

SPI_WriteByte（（uint8_t）（（ReadAddr&0x00FF00）>>8））;/*A15-A8*/

SPI_WriteByte（（uint8_t）（ReadAddr&0x0000FF））;/*A7-A0*/

/*Whilethereisdatatoberead*/

while（NumByteToRead）

{

*pBuffer=SPI_ReadByte（）;

pBuffer++;

NumByteToRead--;

}

/*EnableAcknowledgementtobereadyforanotherreception*/

NSS_CS_DISABLE（）;

SPI_Cmd（SPI1,DISABLE）;

}

//*****wdz*******//

voidSPI_EE_BufferWrite2（u8*pBuffer,u32WriteAddr,u16NumByteToWrite）

{

u32temp=WriteAddr+NumByteToWrite-1;

u32number=WriteAddr+NumByteToWrite-1024*128;

if（temp<1024*128）

{

SPI_EE_BufferWrite（pBuffer,WriteAddr,NumByteToWrite,1）;

}

elseif（WriteAddr<1024*128&&temp>=1024*128）

{

SPI_EE_BufferWrite（pBuffer,WriteAddr,NumByteToWrite-number,1）;

SPI_EE_BufferWrite（pBuffer+NumByteToWrite-number,0,number,2）;

}

elseif（WriteAddr>=1024*128）

{

SPI_EE_BufferWrite（pBuffer,WriteAddr-1024*128,NumByteToWrite,2）;

}

}

voidSPI_EE_Buff

展开阅读全文
相关资源
猜你喜欢
相关搜索

当前位置：首页 > 工程科技 > 能源化工

copyright@ 2008-2022 冰豆网网站版权所有

经营许可证编号:鄂ICP备2022015515号-1