megaspiwriteandreadatmeldataflah.txt

MegaSPI操作AtmelDataFlah源代码c格式 来自 atmel 已经移植gcc了

*    Returns :        None 
* 
*    Parameters :    IntPageAdr    ->    Internal page address to write byte to 
*                    BufferAdr    ->    Decides usage of either buffer 1 or 2 
*                    Data        ->    Data byte to be written 
* 
*    Purpose :        Writes one byte to one of the dataflash 
*                    internal SRAM buffers 
* 
******************************************************************************/ 
void Buffer_Write_Byte (unsigned char BufferNo, unsigned int IntPageAdr, unsigned char Data) 
{ 
     
    DF_CS_DISABLE;                                //make sure to toggle CS signal in order 
    DF_CS_ENABLE;                                //to reset dataflash command decoder 
     
    if (1 == BufferNo)                            //write byte to buffer 1 
    { 
        DF_SPI_RW(Buf1Write);                    //buffer 1 write op-code 
        DF_SPI_RW(0x00);                        //don't cares 
        DF_SPI_RW((unsigned char)(IntPageAdr>>8));//upper part of internal buffer address 
        DF_SPI_RW((unsigned char)(IntPageAdr));    //lower part of internal buffer address 
        DF_SPI_RW(Data);                        //write data byte 
    } 

#ifdef USE_BUFFER2 
    else 
    if (2 == BufferNo)                            //write byte to buffer 2 
    { 
        DF_SPI_RW(Buf2Write);                    //buffer 2 write op-code 
        DF_SPI_RW(0x00);                        //don't cares 
        DF_SPI_RW((unsigned char)(IntPageAdr>>8));//upper part of internal buffer address 
        DF_SPI_RW((unsigned char)(IntPageAdr));    //lower part of internal buffer address 
        DF_SPI_RW(Data);                        //write data byte 
    }         
#endif 
} 


/***************************************************************************** 
* 
*    Function name : Buffer_Write_Str 
* 
*    Returns :        None 
* 
*    Parameters :    BufferNo    ->    Decides usage of either buffer 1 or 2 
*                    IntPageAdr    ->    Internal page address 
*                    No_of_bytes    ->    Number of bytes to be written 
*                    *BufferPtr    ->    address of buffer to be used for copy of bytes 
*                                    from AVR buffer to dataflash buffer 1 (or 2) 
* 
*    Purpose :        Copies one or more bytes to one of the dataflash 
*                    internal SRAM buffers from AVR SRAM buffer 
*                    pointed to by *BufferPtr 
* 
******************************************************************************/ 
void Buffer_Write_Str (unsigned char BufferNo, unsigned int IntPageAdr, unsigned int No_of_bytes, unsigned char *BufferPtr) 
{ 
    unsigned int i; 

    DF_CS_DISABLE;                                //make sure to toggle CS signal in order 
    DF_CS_ENABLE;                                //to reset dataflash command decoder 
     
    if (1 == BufferNo)                            //write byte(s) to buffer 1 
    { 
        DF_SPI_RW(Buf1Write);                    //buffer 1 write op-code 
        DF_SPI_RW(0x00);                        //don't cares 
        DF_SPI_RW((unsigned char)(IntPageAdr>>8));//upper part of internal buffer address 
        DF_SPI_RW((unsigned char)(IntPageAdr));    //lower part of internal buffer address 
        for( i=0; i<No_of_bytes; i++) 
        { 
            DF_SPI_RW(*(BufferPtr));            //write byte pointed at by *BufferPtr to dataflash buffer 1 location 
            BufferPtr++;                        //point to next element in AVR buffer 
        } 
    } 

#ifdef USE_BUFFER2 
    else 
    if (2 == BufferNo)                            //write byte(s) to buffer 2 
    { 
        DF_SPI_RW(Buf2Write);                    //buffer 2 write op-code 
        DF_SPI_RW(0x00);                        //don't cares 
        DF_SPI_RW((unsigned char)(IntPageAdr>>8));//upper part of internal buffer address 
        DF_SPI_RW((unsigned char)(IntPageAdr));    //lower part of internal buffer address 
        for( i=0; i<No_of_bytes; i++) 
        { 
            DF_SPI_RW(*(BufferPtr));            //write byte pointed at by *BufferPtr to dataflash buffer 2 location 
            BufferPtr++;                        //point to next element in AVR buffer 
        } 
    } 
#endif 
} 

/***************************************************************************** 
* 
*    Function name : Buffer_To_Page 
* 
*    Returns :        None 
* 
*    Parameters :    BufferAdr    ->    Decides usage of either buffer 1 or 2 
*                    PageAdr        ->    Address of flash page to be programmed 
* 
*    Purpose :        Transfers a page from dataflash SRAM buffer to flash 
*                     
******************************************************************************/ 
void Buffer_To_Page (unsigned char BufferNo, unsigned int PageAdr) 
{ 
    DF_CS_DISABLE;                                                //make sure to toggle CS signal in order 
    DF_CS_ENABLE;                                                //to reset dataflash command decoder 
         
    if (1 == BufferNo)                                            //program flash page from buffer 1 
    { 
        DF_SPI_RW(Buf1ToFlashWE);                                //buffer 1 to flash with erase op-code 
        DF_SPI_RW((unsigned char)(PageAdr >> (16 - PageBits)));    //upper part of page address 
        DF_SPI_RW((unsigned char)(PageAdr << (PageBits - 8)));    //lower part of page address 
        DF_SPI_RW(0x00);                                        //don't cares 
    } 

#ifdef USE_BUFFER2 
    else     
    if (2 == BufferNo)                                            //program flash page from buffer 2 
    { 
        DF_SPI_RW(Buf2ToFlashWE);                                //buffer 2 to flash with erase op-code 
        DF_SPI_RW((unsigned char)(PageAdr >> (16 - PageBits)));    //upper part of page address 
        DF_SPI_RW((unsigned char)(PageAdr << (PageBits - 8)));    //lower part of page address 
        DF_SPI_RW(0x00);                                        //don't cares 
    } 
#endif 
     
    DF_CS_DISABLE;                                                //initiate flash page programming 
    DF_CS_ENABLE;                                                 
     
    while(!(Read_DF_status() & 0x80));                            //monitor the status register, wait until busy-flag is high 
} 


/***************************************************************************** 
* 
*    Function name : Cont_Flash_Read_Enable 
* 
*    Returns :        None 
* 
*    Parameters :    PageAdr        ->    Address of flash page where cont.read starts from 
*                    IntPageAdr    ->    Internal page address where cont.read starts from 
* 
*    Purpose :        Initiates a continuous read from a location in the DataFlash 
* 
******************************************************************************/ 
void Cont_Flash_Read_Enable (unsigned int PageAdr, unsigned int IntPageAdr) 
{ 
    DF_CS_DISABLE;                                                                //make sure to toggle CS signal in order 
    DF_CS_ENABLE;                                                                //to reset dataflash command decoder 
     
    DF_SPI_RW(ContArrayRead);                                                    //Continuous Array Read op-code 
    DF_SPI_RW((unsigned char)(PageAdr >> (16 - PageBits)));                        //upper part of page address 
    DF_SPI_RW((unsigned char)((PageAdr << (PageBits - 8))+ (IntPageAdr>>8)));    //lower part of page address and MSB of int.page adr. 
    DF_SPI_RW((unsigned char)(IntPageAdr));                                        //LSB byte of internal page address 
    DF_SPI_RW(0x00);                                                            //perform 4 dummy writes 
    DF_SPI_RW(0x00);                                                            //in order to intiate DataFlash 
    DF_SPI_RW(0x00);                                                            //address pointers 
    DF_SPI_RW(0x00); 
} 







头文件和测试代码  

#ifndef __DATAFLASH_INCLUDED 
#define __DATAFLASH_INCLUDED 

//General macro definitions 
//changed to *DF for avr-libc future compatiblity 
#define sbiDF(port,bit)    (port |=  (1<<bit)) 
#define cbiDF(port,bit)    (port &= ~(1<<bit)) 


#define SetBit(x,y)        (x |= (y)) 
#define ClrBit(x,y)        (x &=~(y)) 
#define ChkBit(x,y)        (x  & (y)) 


//Dataflash opcodes 
#define FlashPageRead                0x52    // Main memory page read 
#define FlashToBuf1Transfer         0x53    // Main memory page to buffer 1 transfer 
#define Buf1Read                    0x54    // Buffer 1 read 
#define FlashToBuf2Transfer         0x55    // Main memory page to buffer 2 transfer 
#define Buf2Read                    0x56    // Buffer 2 read 
#define StatusReg                    0x57    // Status register 
#define AutoPageReWrBuf1            0x58    // Auto page rewrite through buffer 1 
#define AutoPageReWrBuf2            0x59    // Auto page rewrite through buffer 2 
#define FlashToBuf1Compare            0x60    // Main memory page to buffer 1 compare 
#define FlashToBuf2Compare            0x61    // Main memory page to buffer 2 compare 
#define ContArrayRead                0x68    // Continuous Array Read (Note : Only A/B-parts supported) 
#define FlashProgBuf1                0x82    // Main memory page program through buffer 1 
#define Buf1ToFlashWE               0x83    // Buffer 1 to main memory page program with built-in erase 
#define Buf1Write                    0x84    // Buffer 1 write 
#define FlashProgBuf2                0x85    // Main memory page program through buffer 2 
#define Buf2ToFlashWE               0x86    // Buffer 2 to main memory page program with built-in erase 
#define Buf2Write                    0x87    // Buffer 2 write 
#define Buf1ToFlash                 0x88    // Buffer 1 to main memory page program without built-in erase 
#define Buf2ToFlash                     0x89    // Buffer 2 to main memory page program without built-in erase 
#define PageErase                   0x81    // Page erase, added by Martin Thomas 

//Pin definitions for interface to the Dataflash 


//Dataflash macro definitions 

//PB4(SS#) for dataflash CS# 
#define DF_CS_ENABLE        cbiDF(PORTB,4) 
#define DF_CS_DISABLE        sbiDF(PORTB,4) 

//PB1 for dataflash WP# 
#define DF_WP_PIN            1  
#define DF_WP_ON            sbiDF(PORTB,DF_WP_PIN)   
#define DF_WP_OFF            sbiDF(PORTB,DF_WP_PIN)  

//Function definitions 
void DF_SPI_init (void); 
unsigned char DF_SPI_RW (unsigned char output); 
unsigned char Read_DF_status (void); 
void Page_To_Buffer (unsigned int PageAdr, unsigned char BufferNo); 
unsigned char Buffer_Read_Byte (unsigned char BufferNo, unsigned int IntPageAdr); 
void Buffer_Read_Str (unsigned char BufferNo, unsigned int IntPageAdr, unsigned int No_of_bytes, unsigned char *BufferPtr); 
void Buffer_Write_Enable (unsigned char BufferNo, unsigned int IntPageAdr); 
void Buffer_Write_Byte (unsigned char BufferNo, unsigned int IntPageAdr, unsigned char Data); 
void Buffer_Write_Str (unsigned char BufferNo, unsigned int IntPageAdr, unsigned int No_of_bytes, unsigned char *BufferPtr); 
void Buffer_To_Page (unsigned char BufferNo, unsigned int PageAdr); 
void Cont_Flash_Read_Enable (unsigned int PageAdr, unsigned int IntPageAdr); 

//Function definitions 2,use macro to replace above function name for using 
#define dfSpiInit                DF_SPI_init  
#define dfSpiRW                    DF_SPI_RW 
#define dfReadStatus            Read_DF_status 
#define dfPageToBuffer            Page_To_Buffer 
#define dfBufferReadByte         Buffer_Read_Byte 
#define dfBufferReadStr         Buffer_Read_Str 
#define dfBufferWriteEnable     Buffer_Write_Enable 
#define dfBufferWriteByte         Buffer_Write_Byte 
#define dfBufferWriteStr         Buffer_Write_Str 
#define dfBufferToPage            Buffer_To_Page 
#define dfContFlashReadEnable    Cont_Flash_Read_Enable 

// *****************************[ End Of DATAFLASH.H ]***************************** 


void at45Test(void) 
{ 
    u08 i=0; 
     
     
    //--------------- 
    rprintf("Start at45 data flash test !\n\r"); 
     
    i=dfReadStatus(); 
    writeSeg7(i); 
    rprintf("\n\r1. Read DF Status : %x \n\r",i); 
     
    dfPageToBuffer(1,1); 
    rprintf("\n\r2. Transfers Page 1 To Buffer 1 \n\r"); 
     
    timerPause(100); 
    i=dfBufferReadByte(1,0x10); 
    rprintf("\n\r3. Read 1 Byte from Buffer 1 , addr = 0x10 , data= %x \n\r",i); 
     
    DF_WP_OFF; 
    dfBufferWriteByte(1,0x10,0x55); 
    rprintf("\n\r4. Write 1 Byte to Buffer 1 , , addr = 0x10 , data= %x \n\r",0x55); 
    DF_WP_ON; 
     
    i=dfBufferReadByte(1,0x10); 
    rprintf("\n\r5. Read 1 Byte from Buffer 1 , addr = 0x10 , data= %x \n\r",i); 
     
    for(i=0;i<0x40;i++) 
    { 
        df_buffer[i]=i; 
    } 
    DF_WP_OFF; 
    dfBufferWriteStr(1,0x10,0x40,df_buffer); 
    rprintf("\n\r6. write 0x40 Bytes to Buffer 1 , addr = 0x10  \n\r"); 
    debugPrintHexTable(0x40,df_buffer); 
    DF_WP_ON; 
     
    for(i=0;i<0x40;i++) 
    { 
        df_buffer[i]=0; 
    } 
     
    dfBufferReadStr(1,0x10,0x40,df_buffer); 
    rprintf("\n\r7. read 0x40 Bytes from Buffer 1 , addr = 0x10  \n\r"); 
    debugPrintHexTable(0x40,df_buffer); 
     
    DF_WP_OFF; 
    dfBufferToPage(1,1); 
    rprintf("\n\r8. Transfers Buffer 1 To Page 1 \n\r"); 
    DF_WP_ON; 
     
    //----------------------- 
    timerPause(500); 
    i=dfReadStatus(); 
    writeSeg7(i); 
    rprintf("\n\r9. Read DF Status : %x \n\r",i); 
    dfPageToBuffer(1,1); 
    rprintf("\n\r10. Transfers Page 1 To Buffer 1 \n\r"); 
    timerPause(100); 
    i=dfBufferReadByte(1,0x10); 
    rprintf("\n\r11. Read 1 Byte from Buffer 1 , addr = 0x10 , data= %x \n\r",i); 
     
    for(i=0;i<0x40;i++) 
    { 
        df_buffer[i]=0; 
    } 
     
    dfBufferReadStr(1,0x10,0x40,df_buffer); 
    rprintf("\n\r12. read 0x40 Bytes from Buffer 1 , addr = 0x10  \n\r"); 
    debugPrintHexTable(0x40,df_buffer); 

}