[font="Courier New"]int main(void){
     u08 eeData = 0x22;
     u16 eeAddr = 20;
     while(EECR & _BV(EEWE));       //    Ждать завершения предыдущей записи
     EEAR = (eeAddr & 0x01ff);      //    Проинициализировать регистр адреса
     EEDR = eeData;
     EECR |= _BV(EEMWE);            //    Установить флаг EEMWE
     EECR |= _BV(EEWE);             //    Начать запись в EEPROM

     while(EECR & _BV(EEWE));       //    Ждать завершения предыдущей записи
//   EEAR = 0;                      //    Сбросить адрес EEPEROM в "0"

     while(EECR & _BV(EEWE));       //    Ждать завершения предыдущей записи
     EEAR = (eeAddr & 0x01ff);      //    Проинициализировать регистр адреса
     EECR |= _BV(EERE);             //    Выполнить чтение
     eeData = EEDR;

     while(EECR & _BV(EEWE));       //    Ждать завершения предыдущей записи
//   EEAR = 0;                      //    Сбросить адрес EEPEROM в "0"[/font]

; RH,RL - адрес
; RA - данные
WREPR:    SBIC    EECR,1
    RJMP    WREPR
    OUT    EEARH,RH
    OUT    EEARL,RL
    OUT    EEDR,RA
    SBI    EECR,2
    SBI    EECR,1
    RET

uint8_t TEEPROM::writeU8(uint16_t addr, uint8_t a)
{
    while(EECR & (1 << EEPE));
    EEAR = addr;
    EEDR = a;
        
        // тут очень желательно запретить все прерывания
    EECR|= (1 << EEMPE);
    EECR|= (1 << EEPE);
        // а тут их снова можно включить

    return EEPROM_OK_RESULT;
}

uint8_t TEEPROM::readU8(uint16_t addr)
{
    while(EECR & (1 << EEPE));
    EEAR = addr;
    EECR|= (1 << EERE);
    return EEDR;
}

     EECR |= _BV(EEMWE);            //    Установить флаг EEMWE
     EECR |= _BV(EEWE);             //    Начать запись в EEPROM

void
EEPROM_write(volatile u08 bankNumber, volatile void *data, volatile u08 length){
cli();
u16 address = 1 + bankNumber * length;
u16 endAddress = address + length;
u08* pointer = (u08*) data;
while(address < endAddress){
while(EECR & _BV(EEWE)); // Ждать завершения предыдущей записи
EEAR = address++; // Проинициализировать регистр адреса
EEDR = *(pointer++);
EECR |= _BV(EEMWE); // Установить флаг EEMWE
EECR |= _BV(EEWE); // Начать запись в EEPROM
}
while(EECR & _BV(EEWE)); // Ждать завершения предыдущей записи
EEAR = 0; // Сбросить адрес EEPEROM в "0"
sei();
}

void
EEPROM_read(volatile u08 bankNumber, volatile void *data, volatile u08 length){
cli();
u16 address = 1 + bankNumber * length;
u16 endAddress = address + length;
u08* pointer = (u08*) data;
while(address < endAddress){
while(EECR & _BV(EEWE)); // Ждать завершения предыдущей записи
EEAR = address++; // Проинициализировать регистр адреса
EECR |= _BV(EERE); // Выполнить чтение
*(pointer++) = EEDR;
}
while(EECR & _BV(EEWE)); // Ждать завершения предыдущей записи
EEAR = 0; // Сбросить адрес EEPEROM в "0"
sei();
}

//
// eerw.h
//

#define EE_SIZE 16 // размер кольцевого буфера для записи в EEPROM

typedef struct tagEEdata
{
uint8_t Adr;
uint8_t Data;
} CEEdata;

void EEinit();
uint8_t ReadEE(uint8_t adr);
uint16_t ReadEE2(uint8_t adr);
uint32_t ReadEE4(uint8_t adr);
void WriteEE(uint8_t data, uint8_t adr);
void WriteEE2(uint16_t data, uint8_t adr);
void WriteEE4(uint32_t data, uint8_t adr);
void WriteNextByte();

//
// eerw.c - функции для чтения/записи в EEPROM
//

#include <avr/io.h>
#include <avr/interrupt.h>
#include "eerw.h"

CEEdata EEdata[EE_SIZE]; // буфер данных для записи в EEPROM
CEEdata *pInPtr, *pOutPtr; // указатели для записи в EEPROM

/*
* работа с EEPROM
*/

void EEinit()
{
pInPtr = pOutPtr = EEdata;
}

uint8_t ReadEE(uint8_t adr)
{
while(EECR & _BV(EEWE))
{}
EEAR = adr;
EECR |= _BV(EERE);
return EEDR;
}

uint16_t ReadEE2(uint8_t adr)
{
uint16_t res1 = ReadEE(adr), res2 = ReadEE(adr+1);
return res1 | (res2<<8);
}

uint32_t ReadEE4(uint8_t adr)
{
uint32_t res1 = ReadEE2(adr), res2 = ReadEE2(adr+2);
return res1 | (res2<<16);
}

void WriteEE(uint8_t data, uint8_t adr)
{
pInPtr->Adr = adr;
pInPtr->Data = data;
if(++pInPtr == &EEdata[EE_SIZE])
pInPtr = EEdata;
cli();
if((EECR & _BV(EERIE)) == 0)
{
EECR |= _BV(EERIE);
WriteNextByte();
}
sei();
}

void WriteEE2(uint16_t data, uint8_t adr)
{
WriteEE(data, adr);
WriteEE((data&0xff00)>>8, adr+1);
}

void WriteEE4(uint32_t data, uint8_t adr)
{
WriteEE2(data, adr);
WriteEE2((data&0xffff0000)>>16, adr+2);
}

void WriteNextByte()
{
EEAR = pOutPtr->Adr;
EEDR = pOutPtr->Data;
if(++pOutPtr == &EEdata[EE_SIZE])
pOutPtr = EEdata;
cli();
EECR |= _BV(EEMWE);
EECR |= _BV(EEWE);
sei();
}

/*
* Обработчик прерывания от EEPROM
*/

ISR(EE_RDY_vect)
{
if(pOutPtr == pInPtr)
EECR &= ~_BV(EERIE);
else
WriteNextByte();
}