mon51 发表于 2017-2-18 14:11:38

发一个LPC1768驱动W25Q256的程序

#ifndef __W25Q256vf_FLASH_H
#define __W25Q256vf_FLASH_H                        
//初始化SPI FLASH的IO口
#define FLASH_ID                 0X00EF4019//W25Q256 spi==id
//W25Q64BV16h4017h
//指令表
#define W25Q256_ReadData                         0x03
#define W25Q256_FastReadData                     0x0B
#define W25Q256_4KByte_BlockERASE                0x20
#define W25Q256_32KByte_BlockErase               0x52
#define W25Q256_64KByte_BlockErase               0xD8
#define W25Q256_ChipErase                        0xC7
#define W25Q256_ByteProgram                      0x02
#define W25Q256_AAI_WordProgram                  0xAD
#define W25Q256_ReadStatusReg                  0x05
#define W25Q256_EnableWriteStatusReg             0x50
#define W25Q256_WriteStatusReg                   0x01
#define W25Q256_WriteEnable                      0x06
#define W25Q256_WriteDisable                     0x04
#define W25Q256_ManufactDeviceID               0x9F
#define W25Q256_EBSY                               0x90
#define W25Q256_JedecDeviceID                  0x70
#define W25Q256_DBSY                           0x80

#define W25Q256_ENABLE_RESET                                                                                0x66       
#define W25Q256_RESET_DEVICE                                                                                0x99
#define W25Q256_Read_4_Addres                                                                                0x13
#define W25Q256_Write_4_Addres                                                                        0x02
#define W25Q256_Enter_4_Addres                                                                        0xb7
#define W24Q256_Exit_4_Addres                                                                                0xe9
#define W24Q256_POWER_DOWN                                                                                        0xB9
#define W24Q256_RELEASE_POWER_DOWN                                                        0xAB
#define W25Q256_ReadStatusReg1                  (W25Q256_ReadStatusReg)
#define W25Q256_ReadStatusReg2                  0x35
#define W25Q256_ReadStatusReg3                       0x15

//****************************************************************************
//sst25256 byte=page4096 byte=sectors (16 page ==sectors)1 blk=共有2048个扇区！
//w25q128== 1024*16*1024/4096   =4096 扇区！
//******************************************************************************
#define SST_OFFSET_SECTOR                  0x00                        //偏移10个扇区再写 1扇区=4K
//******************************************************************************
#define W25Q256_SECTOR_SIZE                        (4096)
#define W25Q256_PAGE_SIZE                                (256)
#define W25Q256_MAX_SECTORS                        (1024l*8l*1024l*4/W25Q256_SECTOR_SIZE)                                        //芯片共有的扇区数！ 2048*2个扇区！
//*****************************************************************************
unsigned char W25Q256_Read_StatusReg(unsigned char command);

       
void W25Q256_Page_Program_SR(unsigned char sr);
unsigned char W25Q256_SPI_Flash_Init(void);
unsigned intSPI_Flash_ReadID(void);                //读取FLASH ID
unsigned char   SPI_Flash_ReadSR(void);      //读取状态寄存器
void SPI_FLASH_Write_SR(unsigned char sr);   //写状态寄存器
void SPI_FLASH_Write_Enable(void);//写使能
void SPI_FLASH_Write_Disable(void); //写保护
void SPI_Flash_Read(unsigned char* pBuffer,unsigned int ReadAddr,unsigned int NumByteToRead);   //读取flash
unsigned int W25Q256_Erase_Sector(unsigned int Dst_Addr);//扇区擦除
unsigned int W25Q256_Wait_Busy(void);         //等待空闲
void SST25V_EBSY(void);
void SST25V_DBSY(void);
void Flash_WriteByte(unsigned char* pBuffer,unsigned int WriteAddr);//写入1Byte数据
void SPI_Flash_Write(unsigned char pBuffer[],unsigned int WriteAddr,unsigned int NumByteToWrite);//结合AB构成的地址自动增加的连续数据的写入
unsigned int W25Q256_Page_Read(unsigned int ReadAddr,unsigned char* pBuffer,unsigned int NumByteToRead);
unsigned int W25Q256_Page_Program(unsigned int WriteAddr,unsigned char* pBuffer,unsigned int NumByteToWrite);
void W25Q256_Erase_Chip(void);
unsigned int W25Q256_ReadID(void);
extern void SPI1_Config(void);
extern unsigned char SPI_ReadWriteByte(unsigned char TxData);
//-------------------------------------------------------------------------------------------------------
//磁盘的信息读出！
unsigned int W25Q256_FS_Read_MSG(unsigned int *ser,unsigned int *rd_len,unsigned int *wr_len,unsigned int *sectCnt );
//**********************************************************************************************
//读取FLASH的文件扇区数量
unsigned int FATFS_Get_DISK_Sectors(void);
//**********************************************************************************************
//文件系统操作读        传入=SECT(扇区512个字节)，CNT=扇区的个数;考虑跨页读和跨快读
unsigned int W25Q256_FS_Rd_Sector(unsigned int sect,unsigned char *buf,unsigned int cnt);
unsigned int W25Q256_FS_Rd_Sect(unsigned int sect,unsigned char *buf,unsigned int cnt);
//*******************************************************************************************************
//对指定一个扇区的写入
//sect=物理扇区地址，OFFSET=物理地址偏移量，CNT是字节数！！
//返回=文件扇区数 cnt
unsigned int W25Q256_ONE_Sector_Wr(unsigned int sect,unsigned offset,unsigned char *buf,unsigned int cnt);
//**********************************************************************************************
//文件系统操作写        传入=SECT(文件扇区512个字节)，CNT=扇区的个数;//从芯片的物理256扇区（256*4=1M）开始读数据】】
//=1 有错误；=0 OK
unsigned int W25Q256_FS_Wr_Sector(unsigned int sect,unsigned char *buf,unsigned int cnt);
unsigned int W25Q256_FS_Wr_Sect(unsigned int sect,unsigned char *buf,unsigned int cnt);

//================================================================================================
//FLASH SPI配置与初始化                                                
unsigned intHW_Flash_Init( void );
//********************************************************************                                          
// 连续的读FLASH数据       (可以跨页读) 多页
unsigned int HW_Flash_Read( unsigned int addr, unsigned int size, unsigned char *buffer );
//**********************************************************************************************************
//一个物理扇区的写入处理 sect =扇区地址号   内部函数！！！
//对指定一个扇区的写入,cnt=字节个数1-4096
//sect=物理扇区地址
//返回=cnt 写入的字节数！
unsigned int HW_Flash_ONE_Sector_Wr(unsigned int sect,unsigned offset,unsigned char *buf,unsigned int cnt);
//**********************************************************************************************************
// 高级的连续向FLASH写数据 (可以跨页写) 多页 有擦除   
unsigned int HW_Flash_EraseWrite( unsigned int dest,        unsigned int size, unsigned char *src );
//************************************************************************************************************                                                                                                                                                                         
// 高级的连续向FLASH写数据(可以跨页写) 多页 无擦除
unsigned int HW_Flash_NotEraseWrite( unsigned int dest, unsigned int size, unsigned char *src );
//************************************************************************************************************                                                                                                                                                                         
// 高级的连续向FLASH写数据(可以跨页写) 多页当写入数据为页开始地址时，自动擦除本页
unsigned int HW_Flash_SmartWrite( unsigned int addr, unsigned int size, unsigned char *src );
//***********************************************************************************************************
// 擦除FLASH一页一个扇区内有8个512字节页，但不是528字节
unsigned int HW_Flash_PageErase( unsigned int page );


#endif

mon51 发表于 2017-2-18 14:11:57

/****************************************Copyright (c)**************************************************                        

********************************************************************************************************/

/* Includes ------------------------------------------------------------------*/
#include         <USE.h>
#include         "W25Q256.h"
#include        <string.h>

//**********************************************************************************************
#define Nf0        0xffffffff
#define Nf1        Nf0,Nf0,Nf0,Nf0,Nf0,Nf0,Nf0,Nf0,Nf0,Nf0,Nf0,Nf0,Nf0,Nf0,Nf0,Nf0 //16个=16*4=64个字节
#define Nf2        Nf1,Nf1,Nf1,Nf1,Nf1,Nf1,Nf1,Nf1,Nf1,Nf1,Nf1,Nf1,Nf1,Nf1,Nf1,Nf1 //16*(16*4)=1024 字节
#define BYTE_1K         (1024)
#define BYTE_4K         (1024*4)
#define BYTE_512         (1024/2)
//**********************************************************************************************
extern unsigned int FAT_Wr_Flash(unsigned int byteAddr,unsigned char *p,unsigned int byteCnt);
extern unsigned int FAT_Rd_Flash(unsigned int byteAddr,unsigned char *p,unsigned int byteCnt);
extern unsigned int FAT_Erase_Flash(unsigned int sectorAddr);
extern void Clr_RTC_ram_flag(void);
//extern FLASH_INFO   FLASH_info;

//**********************************************************************************************
//设置一个4K的0XFF空间
const unsigned int MASK_FF[]={
        Nf2,Nf2,Nf2,Nf2
};
//-------------------------------------------------------------------------------------------------------
//磁盘的信息读出！
unsigned int W25Q256_FS_Read_MSG(unsigned int *ser,unsigned int *rd_len,unsigned int *wr_len,unsigned int *sectCnt ){
        *ser                 =0x01222 ;
        *rd_len         =512;          //固定不变
        *wr_len         =512;          //固定不变
        *sectCnt        =(W25Q256_MAX_SECTORS-SST_OFFSET_SECTOR)*8; //计算扇区的个数; //计算扇区的个数( 1个物理扇区=4096==8个文件扇区！)
        return 1;
}
//**********************************************************************************************
//文件系统操作读        传入=SECT(扇区512个字节)，CNT=扇区的个数;考虑跨页读和跨快读
unsigned int W25Q256_FS_Rd_Sect(unsigned int sect,unsigned char *buf,unsigned int cnt){
        FAT_Rd_Flash(sect<<9,buf,cnt<<9);        //从芯片的物理256扇区（256*4=1M）开始读数据】】
        return 0;
}
//**********************************************************************************************
static unsigned char st25_buf;// 缓存!
//*******************************************************************************************************
//对指定一个扇区的写入
//sect=物理扇区地址，OFFSET=物理地址偏移量，CNT是字节数！！
//返回=文件扇区数 cnt
unsigned int W25Q256_ONE_Sector_Wr(unsigned int sect,unsigned offset,unsigned char *buf,unsigned int cnt){
        unsigned char *p;
        p=st25_buf; //备份数据到ram
        FAT_Rd_Flash(sect<<12,p,4096);        //全部读出来。
        if(memcmp(&p,buf,cnt)){ //数据不相等就要比较是否为0XFF！
                if(memcmp(&p,(unsigned char *)MASK_FF,cnt)){ //数据不是0XFF！
                        memcpy(&p,buf,cnt);    //写入数据到BUFF。
                        FAT_Erase_Flash(sect);                        //删除对应的物理扇区 不是字节地址 4K
                        FAT_Wr_Flash(sect<<12,p,4096);//写一个文件扇区4096字节
                }else{//扇区里的内容是0xff可以直接写。
                       FAT_Wr_Flash((sect*4096 + offset),buf,cnt);//写一个文件扇区512字节
                }
        }
        return cnt/512; //返回文件扇区数量！
}
//**********************************************************************************************
//文件系统操作写        传入=SECT(文件扇区512个字节)，CNT=扇区的个数;//从芯片的物理256扇区（256*4=1M）开始读数据】】
//=1 有错误；=0 OK
unsigned int W25Q256_FS_Wr_Sect(unsigned int sect,unsigned char *buf,unsigned int cnt){
        unsigned int n,Sect,offset;        //Sect=物理地址4K扇区；sect=文件扇区512字节
       
        n=0;//文件扇区的个数
        while(1){
                buf+=n*512;                                                        //缓存地址增加
                Sect=(n+sect)/8;                                //确定地址，除以8 ，是4K一个扇区！ //从芯片的物理256扇区（256*4=1M）开始读数据】】
                offset=(n+sect) % 8;                        //物理扇区内的文件扇区偏移量！
                n=8-offset;                                                                //单物理扇区内的剩余文件扇区的个数：0-8
                if(cnt>n){
                        n=W25Q256_ONE_Sector_Wr(Sect,offset*512,buf,n*512);
                        cnt -=n;
                }else{
                        n=W25Q256_ONE_Sector_Wr(Sect,offset*512,buf,cnt*512);
                        break;
                }
        }
        return 0;
}
/*
static unsigned char buft;
//测试FLASH

void TestFlash_OK(void){
        unsigned int i,err=0;
       
        memset(buft,0xa5,4096);
        for(i=0;i<W25Q256_MAX_SECTORS;i++){
                W25Q256_Erase_Sector(i);
                W25Q256_Page_Read(i*4096,st25_buf,4096);
                if(memcmp(st25_buf,(unsigned char *)MASK_FF,4096)){
                                err++;
                }else{
                                W25Q256_Page_Program(i*4096,buft,4096);
                                W25Q256_Page_Read(i*4096,st25_buf,4096);
                                if(memcmp(st25_buf,buft,4096)){
                                                err++;
                                }
                }
        }
}
*/


mon51 发表于 2017-2-18 14:12:23

#include <USE.h>
#include "W25Q256.h"
#include "lpc1700.h"
//-------------------------------------------------------------------------------------------------------
/* 宏,用于定义SST25VF016B的片选引脚 */
#define SPI_FLASH_CS_LOW()       FIO0PIN &= ~(1 << 6 )
#define SPI_FLASH_CS_HIGH()      FIO0PIN |=(1 << 6 )
#define SPI_RST1                                                                        (1<<28)
//********************************************************************************************************************
#define SPI_RST(x)         FIO4DIR |=SPI_RST1;((x>0)?         (FIO4PIN |=SPI_RST1 )        :(FIO4PIN &= ~SPI_RST1));
//********************************************************************************************************************
#define SPI_FLASH_CS(x) ((x>0)?         (SPI_FLASH_CS_HIGH()) : (SPI_FLASH_CS_LOW()))//设置1，0
//********************************************************************************************************************
void W25Q256_SPI_RST(void){
        SPI_RST(1);
        SPI_RST(0);
        tDelay(0.01);
        SPI_RST(1);
}
//***************************************************************
unsigned charFlash_ReadWriteByte(unsigned chardata){
        SSP1DR = data;
        while (SSP1SR & BSY);               /* Wait for transfer to finish */
        return (SSP1DR);                      /* Return received value       */
}
//********************************************************************************************************************
//上电后软件复位芯片
//********************************************************************************************************************
void W25q256_Reset_With_Soft(void){
       SPI_FLASH_CS(0);                                    //使能器件
       Flash_ReadWriteByte(W25Q256_ENABLE_RESET);   //发送允许复位命令
       SPI_FLASH_CS(1);                            //取消片选   
       SPI_FLASH_CS(0);                                    //使能器件
       Flash_ReadWriteByte(W25Q256_RESET_DEVICE);   //发送允许复位命令
       SPI_FLASH_CS(1);                                    //取消片选   
}
//****************************************************************************
//进入4字节地址模式
//****************************************************************************
void W25Q256_Enable_4_Addres(void){
        SPI_FLASH_CS(0);                                                  //使能器件
        Flash_ReadWriteByte(W25Q256_Enter_4_Addres);         //发送写使能
        SPI_FLASH_CS(1);                                                  //取消片选               
}
//****************************************************************************
//退出4字节地址模式
//****************************************************************************
void W25Q256_Exit_4_Addres(void){
        SPI_FLASH_CS(0);                                                  //使能器件
        Flash_ReadWriteByte(W24Q256_Exit_4_Addres        );         //发送写使能
        SPI_FLASH_CS(1);                                                  //取消片选               
}/********************************************************************************************************************
* Function Name: SPI_FLASH_Init
* Description    : 初始化控制SSI的管脚
* Input          : None
* Output         : None
* Return         : None
* Attention               : None
*******************************************************************************/
void SPI_FLASH_Init(void){
        unsigned int W25Q256_ID;
        SPI_Init (SSP1_PORT);
        W25Q256_SPI_RST();                                                //硬件复位！
        W25q256_Reset_With_Soft();                //软件复位！
        W25Q256_ID=W25Q256_ReadID();
        if( W25Q256_ID==FLASH_ID){
                W25Q256_ID=W25Q256_Read_StatusReg(W25Q256_ReadStatusReg3);        //检测地址模式！
                if(W25Q256_ID & 0x01){        //已经是4地址模式
                       
                }else{
                        //W25Q256_Page_Program_SR(0x02);        //使能状态寄存器中的写存储器
                }
               W25Q256_Enable_4_Addres();//无论什么模式均进入4字节地址模式！
        }
}
//******************************************************************************
void SPI_Lock(unsigned char lock){
        ;//SPI_WP(lock);
}
//******************************************************************************
//unsigned char JB_WP(void){
//        unsigned int i;
       
//        i= FIO4PIN & SPI_WP1;
//        if(i) return UNLOCK;
//        return LOCK;                //测试采用UNLOCK
//}
//**********************************************************************************************
//修改状态寄存器，允许芯片存储器被写
unsigned char W25Q256_SPI_Flash_Init(void){
        //unsigned int W25Q256_ID;
        //        SPI1_Config();                             //初始化SPI
        //        W25Q256_ReadID();
        //        W25Q256_Page_Program_SR(0x02);        //使能状态寄存器中的写存储器
                return 0;                         //0k       
}

//***************************************************************
//读取SPI_FLASH的状态寄存器
//BIT76   5   4   3   2   1   0
//SPR   RVTB BP2 BP1 BP0 WEL BUSY
//SPR:默认0,状态寄存器保护位,配合WP使用
//TB,BP2,BP1,BP0:FLASH区域写保护设置
//WEL:写使能锁定
//BUSY:忙标记位(1,忙;0,空闲)
//默认:0x00
unsigned char W25Q256_Read_StatusReg(unsigned char command){
        unsigned char byte=0;
       SPI_FLASH_CS(0);                            //使能器件
       Flash_ReadWriteByte(command);   //发送读取状态寄存器命令   
       byte=Flash_ReadWriteByte(0Xff);             //读取一个字节
       SPI_FLASH_CS(1);                            //取消片选   
       return byte;
}

//*************************************************************************
//写SPI_FLASH状态寄存器
//只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
//BPL AAI BP3 BP2 BP1 BP0    WEL BUSY
// 00    0                  X    X
//**************************************************************************
void W25Q256_Page_Program_SR(unsigned char sr){       
                SPI_FLASH_CS(0);    //片选
                Flash_ReadWriteByte(W25Q256_EnableWriteStatusReg);//使能写状态寄存器命令
                SPI_FLASH_CS(1);    //取消片选
                SPI_FLASH_CS(0);    //片选                        
                Flash_ReadWriteByte(W25Q256_WriteStatusReg);      //发送写取状态寄存器命令   
                Flash_ReadWriteByte(sr);                                       //写入一个字节 命令！！
                SPI_FLASH_CS(1);                                         //取消片选   
                W25Q256_Wait_Busy();       
}
//****************************************************************************
//SPI_FLASH写使能
//将WEL置位
void W25Q256_Page_Program_Enable(void){
        SPI_FLASH_CS(0);                                  //使能器件
        Flash_ReadWriteByte(W25Q256_WriteEnable);         //发送写使能
        SPI_FLASH_CS(1);                                  //取消片选               
}
//****************************************************************************
//SPI_FLASH写禁止
//将WEL清零
//BPL AAI BP3 BP2 BP1 BP0 WEL BUSY
void W25Q256_Page_Program_Disable(void){
        SPI_FLASH_CS(0);                           //使能器件
        Flash_ReadWriteByte(W25Q256_WriteDisable);   //发送写禁止指令   
        SPI_FLASH_CS(1);                           //取消片选   
}                           
//*********************************************************************************
//发送程序 COM=命令；adr=地址 全部采用4字节地址发送！！！
void SPI_SendAdrOut(unsigned char com,unsigned int adr){
        Flash_ReadWriteByte(com);                                                                                     /* 发送字节数据烧写命令        */
        Flash_ReadWriteByte(adr >> 24);        /* 发送4个字节的地址信息 */       
        Flash_ReadWriteByte(adr >> 16);        /* 发送4个字节的地址信息 */
        Flash_ReadWriteByte(adr >> 8);
        Flash_ReadWriteByte(adr >> 0);
}
//****************************************************************************
//读取芯片ID SST25VF016的是 0XBF41sst25vf064_ID=bf4b
//文帮的是0xEF17
unsigned int W25Q256_ReadID(void){
        unsigned int Temp = 0;      
        SPI_FLASH_CS(0);   
        //SPI_SendAdrOut(W25Q256_ManufactDeviceID,0);             
        Flash_ReadWriteByte(W25Q256_ManufactDeviceID);                //发送读取ID命令
        //读取返回的24位值
        Temp =Flash_ReadWriteByte(0xFF)<<16;                        //高8位数据
        Temp +=Flash_ReadWriteByte(0xFF)<<8;            //底八位数据
        Temp +=Flash_ReadWriteByte(0xFF);                            //底八位数据
        SPI_FLASH_CS(1);
        return Temp;
}
//****************************************************************************
//读取SPI FLASH
//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区
//ReadAddr:开始读取的地址(24bit)
//NumByteToRead:要读取的字节数(最大65535即64k)
unsigned int W25Q256_Page_Read(unsigned int ReadAddr,unsigned char* pBuffer,unsigned int NumByteToRead){
        unsigned int i;   

        //计算物理地址？？ 2014-1-20
        //if ((ReadAddr+NumByteToRead) >(W25Q256_MAX_SECTORS*W25Q256_SECTOR_SIZE)) return 5;//地址错误！
        SPI_FLASH_CS(0);                                                    //使能器件
        SPI_SendAdrOut(W25Q256_FastReadData,ReadAddr);                        //发送读取命令 W25Q256_Read_4_Addres
//        SPI_SendAdrOut(W25Q256_Read_4_Addres,ReadAddr);                        //发送读取命令 W25Q256_Read_4_Addres
        Flash_ReadWriteByte(0XFF);                                                                                           //发送一个哑数据！
        for(i=0;i<NumByteToRead;i++)                pBuffer=Flash_ReadWriteByte(0XFF);   //循环读数
        SPI_FLASH_CS(1);                            //取消片选      
        return 0;
}
//****************************************************************************
//写入扇区已经擦除干净, NumByteToWrite 最好是8，16，32，64，128，256
//pBuffer：为待写数据组
//WriteAddr：所写数据的起始地址
//NumByteToWrite：所要写的数据的长度
unsigned int W25Q256_Page_Write(unsigned char* pBuffer,unsigned int WriteAddr,unsigned int NumByteToWrite){
        unsigned int i;
       
        if(NumByteToWrite==0) return 0;
        W25Q256_Page_Program_Enable();                  //SET WEL
        SPI_FLASH_CS(0);
        SPI_SendAdrOut(W25Q256_ByteProgram,WriteAddr);                                        //发送写页命令
        //发送待写的数据
        for(i=0;i<NumByteToWrite;i++)         Flash_ReadWriteByte(*pBuffer++);
        SPI_FLASH_CS(1);
        W25Q256_Page_Program_Disable();
        W25Q256_Wait_Busy();//等待写完成
        return NumByteToWrite;
}
//****************************************************************************
//写入扇区已经擦除干净, NumByteToWrite 最好是8，16，32，64，128，256
//pBuffer：为待写数据组
//WriteAddr：所写数据的起始地址
//NumByteToWrite：所要写的数据的长度
unsigned intW25Q256_Page_Program(unsigned int WriteAddr,unsigned char* pBuffer,unsigned int NumByteToWrite){
        unsigned int i,page,offset;
       
        if(NumByteToWrite==0) return 3;                                                                                                                                        //溢出
        //if((WriteAddr+NumByteToWrite) >(W25Q256_MAX_SECTORS*W25Q256_SECTOR_SIZE)) return 5;//地址错误！
        W25Q256_Page_Program_SR(0);                                                                                                        //开锁！
        //W25Q256_Page_Program_Enable();                  //SET WEL
        //***************************************************************
        offset=WriteAddr % W25Q256_PAGE_SIZE; //一个页内(256)的偏移地址
        //*********************************************************************
        if(offset){//>0未对其地址！！！！！
                offset =256-offset;
                //*************************************************************************
                //开始地址从WriteAddr，一次写入（256-WriteAddr%256）个字节，以便对齐边界！
                if(NumByteToWrite > offset){
                        W25Q256_Page_Write(pBuffer,WriteAddr,offset);
                        //*****************************************************************************
                        //重新计算后面的写入字节数！
                        NumByteToWrite -=offset;
                        WriteAddr +=offset;
                        pBuffer +=offset;
                }else{
                        W25Q256_Page_Write(pBuffer,WriteAddr,NumByteToWrite); //写入字节数小于一个页内剩余的字节数，直接写完返回。
                        //********************************************************************
                        W25Q256_Page_Program_SR(B1001_1100);                                       //上锁！
                        return 0;
                }
        }
        //---------------------------------------------------------------------------
        page=NumByteToWrite/W25Q256_PAGE_SIZE;           //要写几页
        offset=NumByteToWrite%W25Q256_PAGE_SIZE;        //最后一页的字节数
        //*************************************************************************
        //开始地址从0 ，便可以一次写入256个字节
        for(i=0;i<page;i++){
                W25Q256_Page_Write(pBuffer+i*256,WriteAddr+i*256,256);
        }
        //*************************************************************************
        //继续写完不到一页的数据
        if(offset>0){
                W25Q256_Page_Write(pBuffer,WriteAddr,offset);
        }
        //********************************************************************
        W25Q256_Page_Program_SR(B1001_1100);                                       //上锁！
        return 0;
}
//****************************************************************************
//擦除整个芯片
//整片擦除时间:
//W25X16:25s
//W25X32:40s
//W25X64:40s
//等待时间超长...
void W25Q256_Erase_Chip(void){                                          
        W25Q256_Wait_Busy();
        W25Q256_Page_Program_SR(0);                                                                                                        //开锁！
        W25Q256_Page_Program_Enable();            //SET WEL
        SPI_FLASH_CS(0);                            //使能器件
        Flash_ReadWriteByte(W25Q256_ChipErase);   //发送片擦除命令
        SPI_FLASH_CS(1);                            //取消片选               
        W25Q256_Page_Program_Disable();
        //********************************************************************
        W25Q256_Page_Program_SR(B1001_1100);                                //上锁！
        W25Q256_Wait_Busy();                                     //等待芯片擦除结束
}
//****************************************************************************
//擦除一个扇区Sector_Dst_Addr物理扇区地址号！！
//Dst_Addr:扇区地址 0~511 for w25x16
//擦除一个山区的最少时间:150ms
unsigned int W25Q256_Erase_Sector(unsigned int Sector_Dst_Addr){
        W25Q256_Wait_Busy();
        W25Q256_Page_Program_SR(0);                                                                                                        //开锁！
        W25Q256_Page_Program_Enable();                                                  //SET WEL         
        SPI_FLASH_CS(0);                                                           //使能器件
        SPI_SendAdrOut(W25Q256_4KByte_BlockERASE,(Sector_Dst_Addr)*W25Q256_SECTOR_SIZE);//发送扇区擦除指令必须输入绝对物理地址
        SPI_FLASH_CS(1);                                                                    //取消片选               
        W25Q256_Page_Program_Disable();
        //********************************************************************
        W25Q256_Page_Program_SR(B1001_1100);                                       //上锁！
        //return W25Q256_Wait_Busy();                                    //等待擦除完成
        return 1;
}
//****************************************************************************
//等待空闲
unsigned int W25Q256_Wait_Busy(void){
        unsigned int i;

        i=0;
        while ((W25Q256_Read_StatusReg(W25Q256_ReadStatusReg1) & 0x01)==0x01){   // 等待BUSY位清空
                        if(i++>299000) return 1; //一直忙！
        }
        return 0;
}
//****************************************************************************
//文件接口的读、写、删除
unsigned int FAT_Wr_Flash(unsigned int byteAddr,unsigned char *p,unsigned int byteCnt){
        W25Q256_Page_Program(byteAddr+SST_OFFSET_SECTOR*4096,p,byteCnt);
        return 0;
}
//****************************************************************************
//文件接口的读、写、删除
unsigned int FAT_Rd_Flash(unsigned int byteAddr,unsigned char *p,unsigned int byteCnt){
        W25Q256_Page_Read(byteAddr+SST_OFFSET_SECTOR*4096,p,byteCnt);
        return 0;
}
//****************************************************************************
//文件接口的读、写、删除
unsigned int FAT_Erase_Flash(unsigned int sectorAddr){
        W25Q256_Erase_Sector(sectorAddr+SST_OFFSET_SECTOR);
        return 0;       
}









lylm123 发表于 2017-2-18 15:13:37

学习一下，谢谢分享。

anxiangbo 发表于 2017-2-18 16:48:14

谢谢分享。最好发个完整的工程文件。

fenjinzhe 发表于 2017-2-18 16:56:41

谢谢分享，用时再来

talkingbeast 发表于 2017-2-18 21:43:09

上传驱动文件更友好点，谢谢分享。

yangzi8000 发表于 2017-5-15 12:08:47

能发个电路图吗

zhcj66 发表于 2017-5-20 13:31:06

mon51 发表于 2017-2-18 14:12
#include
#include "W25Q256.h"
#include "lpc1700.h"


W25Qxxx存储有坏块出现吗？

mon51 发表于 2017-5-20 14:17:00

zhcj66 发表于 2017-5-20 13:31
W25Qxxx存储有坏块出现吗？

没有发现过。

zhcj66 发表于 2017-5-20 14:41:09

mon51 发表于 2017-5-20 14:17
没有发现过。

那直接当EEPROM使用 保存字库不知道安全不，不打算使用FATFS， 感觉使用FATFS后效率会低很多

mon51 发表于 2017-5-20 16:37:53

zhcj66 发表于 2017-5-20 14:41
那直接当EEPROM使用 保存字库不知道安全不，不打算使用FATFS， 感觉使用FATFS后效率会低很多 ...

请问有1G-BYTE 的EEROM码？

Excellence 发表于 2017-7-26 16:18:12

lpc1768用了很多年，熟悉的寄存器。DIR,SET,CLR

jdlee 发表于 2018-1-7 14:55:02

谢谢分享   
页: [1]
查看完整版本: 发一个LPC1768驱动W25Q256的程序