STM32之SPI读写外部FLASH（SST25VF016B）转载！

orange-208

void SPI_Flash_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)

SPI_FLASH_Write_SR(0x02);//使能状态寄存器中的写存储器

         SST25V_DBSY();
SPI_FLASH_Write_SR(0x02);//使能状态寄存器中的写存储器
         SST25V_DBSY();
实验目的：将数据写入外部FLASH中，然后再读出来显示在LCD上
实验平台：基于STM32F103C8T6的彩屏开发板
FLASH：SST25VF016B

flash_SST.c

#include "flash_SST.h"
#include "spi.h"
#include "delay.h"

//4Kbytes为一个Sector
//16个扇区为1个Block
//SST25VF016B
//容量为2M字节,共有32个Block(块),512个Sector（扇区）
//初始化SPI FLASH的IO口
//修改状态寄存器，允许芯片存储器被写
void SPI_Flash_Init(void)
{
RCC->APB2ENR|=1<<2;        //PORTA时钟使能        
GPIOA->CRH&=0XFFFFFF0F;
GPIOA->CRH|=0X00000030;    //PA9 推挽         
GPIOA->ODR|=1<<9;          //PA9上拉
SPIx_Init();               //初始化SPI
SPI_FLASH_Write_SR(0x02);  //使能状态寄存器中的写存储器
SST25V_DBSY();
}

//读取SPI_FLASH的状态寄存器
//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
u8 SPI_Flash_ReadSR(void)  
{
u8 byte=0;  
SPI_FLASH_CS=0;                            //使能器件  
SPIx_ReadWriteByte(SST25_ReadStatusReg);    //发送读取状态寄存器命令   
byte=SPIx_ReadWriteByte(0Xff);             //读取一个字节
SPI_FLASH_CS=1;                                 //取消片选   
return byte;  
}

//写SPI_FLASH状态寄存器
//只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
void SPI_FLASH_Write_SR(u8 sr)  
{  
SPI_FLASH_CS=0;    //片选
SPIx_ReadWriteByte(SST25_EnableWriteStatusReg);  //使能写状态寄存器命令  
SPI_FLASH_CS=1;                                                 //取消片选
SPI_FLASH_CS=0;                                                  //片选                        
SPIx_ReadWriteByte(SST25_WriteStatusReg);   //发送写取状态寄存器命令   
SPIx_ReadWriteByte(sr);                                //写入一个字节
SPI_FLASH_CS=1;                                        //取消片选                 
}


//SPI_FLASH写使能
//将WEL置位  
void SPI_FLASH_Write_Enable(void)  
{
SPI_FLASH_CS=0;                            //使能器件  
SPIx_ReadWriteByte(SST25_WriteEnable);      //发送写使能
SPI_FLASH_CS=1;                            //取消片选               
}

//SPI_FLASH写禁止
//将WEL清零
void SPI_FLASH_Write_Disable(void)  
{
SPI_FLASH_CS=0;                                       //使能器件  
SPIx_ReadWriteByte(SST25_WriteDisable);     //发送写禁止指令   
SPI_FLASH_CS=1;                                       //取消片选               
}                             

//读取芯片ID SST25VF016的是 0XBF41
u16 SPI_Flash_ReadID(void)
{
u16 Temp = 0;      
SPI_FLASH_CS=0;
   
//发送读取ID命令                           
SPIx_ReadWriteByte(0x90);

//发送24位的地址        
SPIx_ReadWriteByte(0x00);            
SPIx_ReadWriteByte(0x00);            
SPIx_ReadWriteByte(0x00);

//读取返回的16位值                              
Temp=SPIx_ReadWriteByte(0xFF)<<8;  //高8位数据
Temp+=SPIx_ReadWriteByte(0xFF);      //底八位数据
SPI_FLASH_CS=1;                                   
return Temp;
}

//读取SPI FLASH
//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区
//ReadAddr:开始读取的地址(24bit)
//NumByteToRead:要读取的字节数(最大65535即64k)
void SPI_Flash_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)  
{
u16 i;                                                                                                               
SPI_FLASH_CS=0;                                       //使能器件  
SPIx_ReadWriteByte(SST25_ReadData);         //发送读取命令

//发送24bit地址   
SPIx_ReadWriteByte((u8)((ReadAddr)>>16));   
SPIx_ReadWriteByte((u8)((ReadAddr)>>8));  
SPIx_ReadWriteByte((u8)ReadAddr);
for(i=0;i<NumByteToRead;i++)
{
  pBuffer=SPIx_ReadWriteByte(0XFF);   //循环读数
}
SPI_FLASH_CS=1;                            //取消片选               
}

//地址自动增加的写数据A
void AutoAddressIncrement_WordProgramA(u8 Byte1, u8 Byte2, u32 Addr)
{
SPI_FLASH_Write_Enable();
SPI_FLASH_CS=0;
SPIx_ReadWriteByte(SST25_AAI_WordProgram);

//输入所要写数据的起始地址
SPIx_ReadWriteByte((Addr & 0xFF0000) >> 16);
SPIx_ReadWriteByte((Addr & 0xFF00) >> 8);
SPIx_ReadWriteByte(Addr & 0xFF);                                  //发送最初的两个数据
SPIx_ReadWriteByte(Byte1);
SPIx_ReadWriteByte(Byte2);
SPI_FLASH_CS=1;
SPI_Flash_Wait_Busy();
}

//地址自动增加的写数据B
void AutoAddressIncrement_WordProgramB(u8 state,u8 Byte1, u8 Byte2)
{
SPI_FLASH_Write_Enable();
SPI_FLASH_CS=0;
SPIx_ReadWriteByte(SST25_AAI_WordProgram);
SPIx_ReadWriteByte(Byte1);
SPIx_ReadWriteByte(Byte2);
SPI_FLASH_CS=1;
SPI_Flash_Wait_Busy();
if(state==1)
{
  SPI_FLASH_Write_Disable();
}
SPI_Flash_Wait_Busy();
}

//结合AB构成的地址自动增加的连续数据的写入
//具有先擦除待写区域的功能
//pBuffer：为待写数据组
//WriteAddr：所写数据的起始地址
//NumByteToWrite：所要写的数据的长度
void SPI_Flash_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
{
u16 i,temp;
u32 secpos;
u16 secoff;
u16 secremain;     
//以下代码为擦除待写区域的代码
secpos=WriteAddr/4096;                                           //扇区（4K）地址0~511 for     SST25VF016
secoff=WriteAddr@96;                                                             //在扇区内的偏移
secremain=4096-secoff;                                                           //扇区剩余空间大小
if(NumByteToWrite<secremain)                                                  //剩余空间大于所存数据
{
  temp=1;
}
else                                                                 //剩余空间小于所存数据
{
  i=NumByteToWrite-secremain;                           //判断还占了几个扇区
if(i%96==0)
       temp=i/4096+1;
else
       temp=i/4096+2;
}
for(i=0;i<temp;i++)
{
  SPI_Flash_Erase_Sector((secpos+i)*4096);                   //擦除将要写入数据的扇区   
}
  //以下代码为将数据写入指定地址的代码
if(NumByteToWrite%2==0)
{
  temp=NumByteToWrite/2-1;
}
else
{
  temp=NumByteToWrite/2;
}
AutoAddressIncrement_WordProgramA(pBuffer[0], pBuffer[1],WriteAddr );                                        //开始写数据
for(i=1;i<temp;i++)
{
  AutoAddressIncrement_WordProgramB(0,pBuffer[2*i], pBuffer[2*i+1]);
}
if(NumByteToWrite%2==0)
{
  AutoAddressIncrement_WordProgramB(1,pBuffer[NumByteToWrite-2], pBuffer[NumByteToWrite-1]);   //结束写数据
}
else
{
  AutoAddressIncrement_WordProgramB(1,pBuffer[NumByteToWrite-1],0);                                         //结束写数据
}

//写入1Byte数据
//pBuffer:待写的数据
//WriteAddr：待写数据的地址
void Flash_WriteByte(u8* pBuffer,u32 WriteAddr)
{
u32 secpos;
secpos=WriteAddr/4096;                                   //扇区地址 0~511 for w25x16  4096=4k
SPI_Flash_Erase_Sector(secpos);                        //擦除这个扇区
SPI_FLASH_Write_Enable();                              //SET WEL
SPI_FLASH_CS=0;                                            //使能器件  
SPIx_ReadWriteByte(SST25_ByteProgram );       //发送写页命令

//发送24bit地址   
SPIx_ReadWriteByte((u8)((WriteAddr)>>16));  
SPIx_ReadWriteByte((u8)((WriteAddr)>>8));  
SPIx_ReadWriteByte((u8)WriteAddr);                  //发送待写的数据
SPIx_ReadWriteByte(pBuffer[0]);
SPI_FLASH_CS=1;
SPI_Flash_Wait_Busy();                                     //等待写完成
}

//擦除整个芯片
//整片擦除时间:
//W25X16:25s
//W25X32:40s
//W25X64:40s
//等待时间超长...
void SPI_Flash_Erase_Chip(void)  
{                                            
SPI_FLASH_Write_Enable();                          //SET WEL
SPI_Flash_Wait_Busy();  
SPI_FLASH_CS=0;                                       //使能器件  
SPIx_ReadWriteByte(SST25_ChipErase);       //发送片擦除命令
SPI_FLASH_CS=1;                                     //取消片选               
SPI_Flash_Wait_Busy();                              //等待芯片擦除结束
}

//擦除一个扇区
//Dst_Addr:扇区地址 0~511 for w25x16
//擦除一个山区的最少时间:150ms
void SPI_Flash_Erase_Sector(u32 Dst_Addr)  
{  
SPI_FLASH_Write_Enable();                                       //SET WEL           
SPI_Flash_Wait_Busy();  
SPI_FLASH_CS=0;                                                   //使能器件  
SPIx_ReadWriteByte(SST25_4KByte_BlockERASE);      //发送扇区擦除指令
SPIx_ReadWriteByte((u8)((Dst_Addr)>>16));            //发送24bit地址   
SPIx_ReadWriteByte((u8)((Dst_Addr)>>8));  
SPIx_ReadWriteByte((u8)Dst_Addr);
SPI_FLASH_CS=1;                                            //取消片选               
SPI_Flash_Wait_Busy();                                    //等待擦除完成
}

//等待空闲
void SPI_Flash_Wait_Busy(void)  
{  
while ((SPI_Flash_ReadSR()&0x01)==0x01);       // 等待BUSY位清空
}

void SST25V_EBSY(void)
{
SPI_FLASH_CS=0;
SPIx_ReadWriteByte( SST25_EBSY);
SPI_FLASH_CS=1;   
}

void SST25V_DBSY(void)
{
SPI_FLASH_CS=0;
SPIx_ReadWriteByte( SST25_DBSY);
SPI_FLASH_CS=1;   
}


Flash.h

#ifndef __FLASH_SST_H
#define __FLASH_SST_H                        
#include "sys.h"
#define      SPI_FLASH_CS PAout(9)      //选中FLASH                                 
#define FLASH_ID 0XBF41                    //SST25VF016读写

//指令表
#define SST25_ReadData                           0x03
#define SST25_FastReadData                      0x0B
#define SST25_4KByte_BlockERASE             0x20
#define SST25_32KByte_BlockErase             0x52
#define SST25_64KByte_BlockErase             0xD8
#define SST25_ChipErase                           0xC7
#define SST25_ByteProgram                      0x02
#define SST25_AAI_WordProgram              0xAD
#define SST25_ReadStatusReg                   0x05
#define SST25_EnableWriteStatusReg         0x50
#define SST25_WriteStatusReg                  0x01
#define SST25_WriteEnable                       0x06
#define SST25_WriteDisable                      0x04
#define SST25_ManufactDeviceID              0x90
#define SST25_JedecDeviceID                   0x9F
#define SST25_EBSY                                0x70
#define SST25_DBSY                                0x80

void SPI_Flash_Init(void);
u16  SPI_Flash_ReadID(void);                //读取FLASH ID
u8     SPI_Flash_ReadSR(void);              //读取状态寄存器
void SPI_FLASH_Write_SR(u8 sr);          //写状态寄存器
void SPI_FLASH_Write_Enable(void);     //写使能
void SPI_FLASH_Write_Disable(void);     //写保护
void SPI_Flash_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead);   //读取flash
void SPI_Flash_Erase_Chip(void);                                                         //整片擦除
void SPI_Flash_Erase_Sector(u32 Dst_Addr);                                        //扇区擦除
void SPI_Flash_Wait_Busy(void);                                                         //等待空闲
void SST25V_EBSY(void);
void SST25V_DBSY(void);
void Flash_WriteByte(u8* pBuffer,u32 WriteAddr);                                       //写入1Byte数据
void AutoAddressIncrement_WordProgramA(u8 Byte1, u8 Byte2, u32 Addr);  //地址自动增加的写数据A
void AutoAddressIncrement_WordProgramB(u8 state,u8 Byte1, u8 Byte2);     //地址自动增加的写数据B
void SPI_Flash_Write(u8 pBuffer[],u32 WriteAddr,u16 NumByteToWrite);       //结合AB构成的地址自动增加的连续数据的写入
#endif

main.c

主函数：
#include<stm32f10x_lib.h>
#include"common.h"
#include"TFTLCD.h"
#include"spi.h"
#include"key.h"
#include"flash.h"
const u8 TEXT_Buffer[]={"Chen An SST25VF"};       //待写入flash的数据
#define SIZE sizeof(TEXT_Buffer)                           //计算待写入数据的长度
int main(void)
{
         u8 key;
         u8 datatemp[SIZE];                                       //开辟空间用于存放从flash读回的数据
         Stm32_Clock_Init(9);                                 //系统时钟初始化
         delay_init(72);                                          //延时函数的初始化
         LCD_Init();                                               //LCD初始化
         KEY_Init();                                               //按键初始化
         SPI_Flash_Init();                                       //SPI关于flash的硬件接口初始化
         POINT_COLOR=RED;                                //设置字体颜色
         while(SPI_Flash_ReadID()!=FLASH_ID)        //检验flash是否存在
         {
                   LCD_ShowString(60,130,"SST25VF Check Failed!");
                   delay_ms(500);
         }
         LCD_ShowString(60,130,"SST25VF Ready!");
         LCD_ShowString(60,150,"KEY1:Write KEY2:Read");
         POINT_COLOR=BLUE;
         while(1)
         {
                   key=KEY_Scan();                     //按键扫描
                   if(key==1)                    //按键1按下，开始写数据到flash
                   {
                            LCD_Fill(0,170,239,319,WHITE);
                            LCD_ShowString(60,170,"Start Write SST25V");
                            SPI_Flash_Write((u8*)TEXT_Buffer,1000,SIZE);                 //写数据
                   LCD_ShowString(60,170,"SST25V Write Finished");
                   }
                   if(key==2)                            //按键2按下，开始从flash读回数据
                   {
                            LCD_ShowString(60,170,"Start Read SST25V");
                            SPI_Flash_Read(datatemp,1000,SIZE);                              //读数据
                            LCD_ShowString(60,170,"The Data Is");
                            LCD_ShowString(60,190,datatemp);

                   }      
         }
}
总结：1.开始的时候，读取FLASH的ID成功，我觉得芯片一切正常，但是写入数据后读回来的全是“满屏”，纠结了一天才发现原
        来是FLASH没有进行初始化，没有写 （SPI_FLASH_Write_SR(0x02);//使能状态寄存器中的写存储器  SST25V_DBSY() )
        这两句导致数据无法写入FLASH。
      2.我在写程序的时候犯了个很低级的失误，在写乘法时用了 2i 结果一直提示有错误却没发现，直到过了半个小时才反应过
        该写成 2*i
      3.这个SST25VF016的关键在于连续数据的写入，需要仔细研究图二，我也是参考了一个网友的思路，在他得基础（A和B）拓
        展出最后的 SPI_FlashWrite 函数的，不过该函数还有很多的不确定因素，大家要结合主函数中的 SIZE 来进行思考。

lisn3188

要改一个字节需要擦除整个扇区4K。。。。还是AT45DB 好用一些
另外，斜体字的代码，看着真是吃力

orange-208

//结合AB构成的地址自动增加的连续数据的写入
//具有先擦除待写区域的功能
//pBuffer：为待写数据组
//WriteAddr：所写数据的起始地址
//NumByteToWrite：所要写的数据的长度
void SPI_Flash_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
{
u16 i,temp;
u32 secpos;
u16 secoff;
u16 secremain;     
//以下代码为擦除待写区域的代码
secpos=WriteAddr/4096;                                           //扇区（4K）地址0~511 for     SST25VF016
secoff=WriteAddr%4096;                                                             //在扇区内的偏移
secremain=4096-secoff;                                                           //扇区剩余空间大小
if(NumByteToWrite<secremain)                                                  //剩余空间大于所存数据
{
  temp=1;
}
else                                                                 //剩余空间小于所存数据
{
  i=NumByteToWrite-secremain;                           //判断还占了几个扇区
if(i%4096==0)
       temp=i/4096+1;
else
       temp=i/4096+2;
}
for(i=0;i<temp;i++)
{
  SPI_Flash_Erase_Sector((secpos+i)*4096);                   //擦除将要写入数据的扇区   
}
  //以下代码为将数据写入指定地址的代码
if(NumByteToWrite%2==0)
{
  temp=NumByteToWrite/2-1;
}
else
{
  temp=NumByteToWrite/2;
}
AutoAddressIncrement_WordProgramA(pBuffer[0], pBuffer[1],WriteAddr );                                        //开始写数据
for(i=1;i<temp;i++)
{
  AutoAddressIncrement_WordProgramB(0,pBuffer[2*i], pBuffer[2*i+1]);
}
if(NumByteToWrite%2==0)
{
  AutoAddressIncrement_WordProgramB(1,pBuffer[NumByteToWrite-2], pBuffer[NumByteToWrite-1]);   //结束写数据
}
else
{
  AutoAddressIncrement_WordProgramB(1,pBuffer[NumByteToWrite-1],0);                                         //结束写数据
}

}

bwsz1

顶楼主  哈哈那个96的改过了了  我没看下面的跟帖 还纳闷了一下 怎么来了个96 哈哈

csb1030

顶起，好东西，我喜欢

chenxujiaoyang

你确定这个函数是对的？？！！

wsammy880

good for reference

wjs81906

MARK,MARK.

doujiang

chenxujiaoyang 发表于 2012-12-25 17:49
你确定这个函数是对的？？！！

同问

LingYi

chenxujiaoyang 发表于 2012-12-25 17:49
你确定这个函数是对的？？！！

大侠，我测试过了，这个读数据指令确实是错的，读出的数据全部是0XFF。

ljq673091

for(i=0;i<temp;i++)
{
  SPI_Flash_Erase_Sector((secpos+i)*4096);                   //擦除将要写入数据的扇区   
}
这样子的话 不是每次一定要写入一个扇区。如果你每次只写入64个byte，再写下去就要之前的数据清掉了。

it_yrj

收下了，多谢分享

it_yrj

楼主，您的SPIx_ReadWriteByte（）函数在哪呢？没找到啊

dtdzlujian

有时间来好好学一下了

569350810

chenxujiaoyang 发表于 2012-12-25 17:49
你确定这个函数是对的？？！！

1. //读取SPI FLASH  
   
2. //在指定地址开始读取指定长度的数据
   
3. //pBuffer:数据存储区
   
4. //ReadAddr:开始读取的地址(24bit)
   
5. //NumByteToRead:要读取的字节数(最大65535)
   
6. void SPI_Flash_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)   
   
7. {
   
8. u16 i;                                                                                                        
   
9. SPI_FLASH_CS = 0;                                  //使能器件   
   
10. SPI1_ReadWriteByte(SST25VF_ReadData);                //发送读取命令   
    
11. SPI1_ReadWriteByte((u8)((ReadAddr)>>16));          //发送24bit地址   
    
12. SPI1_ReadWriteByte((u8)((ReadAddr)>>8));   
    
13. SPI1_ReadWriteByte((u8)ReadAddr);  
    
14. SPI1_ReadWriteByte(0xFF);                //还要发个空字节
    
15. for(i=0; i<NumByteToRead; i++)
    
16. {
    
17. pBuffer[i] = SPI1_ReadWriteByte(0xFF);           //循环读数
    
18. }
    
19. SPI_FLASH_CS = 1;                             //取消片选                  
    
20. }
    

复制代码

liyang121316

呵呵。

jeffu668

喜欢抄的人太多了，连一个读写函数都不发上，这技术做的太马虎了，以下基于STM8L101 硬件SPI，测试通过，保证可用。

BYTE SPIx_ReadWriteByte(BYTE TxData)
{
  BYTE   rx_dat;
  BYTE   retry=0;
while(!(SPI_SR&0X02));//等待发射空
        {
        retry++;
        if(retry>100)
        return 0;
        }  
  SPI_DR = TxData;//发送数据
  retry=0;

while(!(SPI_SR&0X01));//数据非空，表明接收数据。
        {
        retry++;
        if(retry>100)
        return 0;
        }  
  rx_dat=SPI_DR;        
  return rx_dat;//读取数据
}

81840710

请问这个可以直接烧写BIN文件到SST25VF016B吗?还是需要改 bootloader再通过串口下载到SST25VF016B呀

PSIR

请问一下楼主，这个 SPIx_Init();  初始化SPI函数写在哪里，能提供下吗？

cc1987

mark 学习了