1> EEPROM.h: 

#ifndef _EEPROM_H_ 
#define _EEPROM_H_ 

#ifdef  _EEPROM_C_ 
#define EXTERN 
#else 
#define EXTERN  extern 
#endif 

typedef enum 
{ 
    EEPROM_WRITE_STAT_EMPTY,  // no data in the EEPROM Write buf 
    EEPROM_WRITE_STAT_FILL,   // have data in the EEPROM Write but not full 
    EEPROM_WRITE_STAT_FULL    // EEPROM Write buf full 
}EEPROM_WRITE_STAT; 

typedef enum 
{ 
    EEPROM_SERVER_STAT_NULL, 
    EEPROM_SERVER_STAT_WRITING 
}EEPROM_SERVER_STAT; 

typedef struct 
{ 
    unsigned int  wAddress; 
    unsigned char bVal; 
}S_EEPROM_POSITION; 

#define EEPROM_WRITE_BUF_SIZE   16 
EXTERN S_EEPROM_POSITION _sEEPROMBuf[EEPROM_WRITE_BUF_SIZE]; 
EXTERN volatile EEPROM_WRITE_STAT _eEEPROMWriteStat; 
EXTERN volatile U8  _bEEPROMWritePoint; 
EXTERN volatile U8  _bEEPROMReadPoint; 
EXTERN volatile EEPROM_SERVER_STAT _eEEPROMServerStat; 

EXTERN U8 WriteDataToEEPROM(U16 wAddress, U8 bVal); 
EXTERN U8 ReadDataFromEEPROM(U16 wAddress, U8 *pbVal); 
EXTERN void EEPROMServer(void); 
EXTERN void InitEEPROM(void); 

#undef  EXTERN 
#endif 

2> EEPROM.c 

#define _EEPROM_C_ 

#include    "DrvHead.h" 

#pragma interrupt_handler EE_READY:iv_EE_READY 
void EE_READY(void) 
{ 
    if(_eEEPROMWriteStat != EEPROM_WRITE_STAT_EMPTY) 
    { 
        EEAR = _sEEPROMBuf[_bEEPROMReadPoint].wAddress; 
        EEDR = _sEEPROMBuf[_bEEPROMReadPoint].bVal; 
        EECR |= BIT(EEMWE); 
        EECR |= BIT(EEWE); 
        _eEEPROMServerStat = EEPROM_SERVER_STAT_WRITING; 
        _bEEPROMReadPoint++; 
        if(_bEEPROMReadPoint >= EEPROM_WRITE_BUF_SIZE) 
        { 
            _bEEPROMReadPoint = 0; 
        } 
        if(_bEEPROMReadPoint == _bEEPROMWritePoint) 
        { 
            _eEEPROMWriteStat = EEPROM_WRITE_STAT_EMPTY; 
        } 
        else 
        { 
            _eEEPROMWriteStat = EEPROM_WRITE_STAT_FILL; 
        } 
    } 
    else 
    { 
        EECR &= ~BIT(EERIE); 
        _eEEPROMServerStat = EEPROM_SERVER_STAT_NULL; 
    } 
} 


U8 WriteDataToEEPROM(U16 wAddress, U8 bVal) 
{ 
    if(_eEEPROMWriteStat == EEPROM_WRITE_STAT_FULL) 
    { 
        return RET_BUSY; 
    } 
    _sEEPROMBuf[_bEEPROMWritePoint].wAddress = wAddress; 
    _sEEPROMBuf[_bEEPROMWritePoint].bVal = bVal; 
    _bEEPROMWritePoint++; 
    if(_bEEPROMWritePoint >= EEPROM_WRITE_BUF_SIZE) 
    { 
        _bEEPROMWritePoint = 0; 
    } 
    if(_bEEPROMWritePoint == _bEEPROMReadPoint) 
    { 
        _eEEPROMWriteStat = EEPROM_WRITE_STAT_FULL; 
    } 
    else 
    { 
        _eEEPROMWriteStat = EEPROM_WRITE_STAT_FILL; 
    } 
    return RET_SUCCESS; 
} 


U8 ReadDataFromEEPROM(U16 wAddress, U8 *pbVal) 
{ 
    if(EECR & BIT(EEWE)) 
    { 
        return RET_BUSY; 
    } 
    EEAR = wAddress; 
    EECR |= BIT(EERE); 
    *pbVal = EEDR; 
    return RET_SUCCESS; 
} 


void EEPROMServer(void) 
{ 
    if( (_eEEPROMServerStat == EEPROM_SERVER_STAT_NULL) 
        && (_eEEPROMWriteStat != EEPROM_WRITE_STAT_EMPTY) ) 
    { 
        EECR |= BIT(EERIE); 
    } 
} 


void InitEEPROM(void) 
{ 
    _eEEPROMWriteStat = EEPROM_WRITE_STAT_EMPTY; 
    _bEEPROMWritePoint = 0; 
    _bEEPROMReadPoint = 0; 
    _eEEPROMServerStat = EEPROM_SERVER_STAT_NULL; 
    EECR = 0x00; 
}