uint8_t a1;
double a2;
uint16_t a3;

__eeprom int i, j;
__eeprom int k @0x14;

#include <stdint.h>

#include <avr/eeprom.h>

typedef struct {
    uint8_t a;
    uint16_t b;
    float f;
} config;

config cfg;

config ee_cfg EEMEM =
{
    12, 1078, 3.5
};

uint16_t ee_u EEMEM = 65000;

float ff;
uint16_t u;

uint16_t foo(void)
{
    ff = 7.5;
    eeprom_read_block( &cfg, &ee_cfg, sizeof(cfg) );        // можно всю структуру
    eeprom_write_block( &ff, &ee_cfg.f, sizeof(float) );    // можно одно поле
    uu = eeprom_read_word( &ee_cfg.b );    
    return eeprom_read_word( &ee_u);            // само собой, можно и одночные переменные
}

//все, что в еепроме, тотально объединено в структуру
typedef struct
{
****
} paramset_t;
// __MAIN__ определен там, где у нас main()
#ifdef __MAIN__
EEMEM paramset_t paramset = {большой блок инициализации};
#else
extern paramset_t paramset;
#endif

void
eeprom_manager::write( const void *buf, uint16_t addr, uint16_t len)
{
    ee_guard pg; // тута мьютекс спрятан

    const uint8_t *ptr = reinterpret_cast< const uint8_t* >(buf);

    do {
        uint8_t to_write = *ptr++;
        EEAR = addr++;
        EECR |= 1 << EERE;
        if( EEDR == to_write)
            continue;

        write_done.Clear();
        EEDR = to_write;
        {
            TCritSect cs;
            EECR |= 1 << EEMWE;
            EECR |= 1 << EEWE;
            EECR |= 1 << EERIE;
        }
        write_done.Wait();
    } while( --len);
}


OS_INTERRUPT void
EE_READY_vect()
{
    OS::TISRW isrw;
    EECR &= ~(1 << EERIE);
    eeprom_manager::write_done.SignalISR();
}

//=============================================================================
// Автомат записи в EEPROM
//=============================================================================
void EepromRun()
{

  if (EECR & (1<<EEWE)) return;                // идет запись ? тогда отваливаем

  if (CurrState==EE_FREE)                      // если еще не пишем
  {
    if (EE_StatUpdate==EEPROM_STAT_UPDATE)
    {                                          // обновляем статистику

      CurrBase=0;                      // первая копия
      BYTE *ps=(BYTE *)&modbase.Resets;
      BYTE *pd=(BYTE *)&EEStat;        // сохраняем во временном буфере
      BYTE len=(sizeof(EEStat)-2)/2;   // CRC не копируем
      do {                             // т.к. статистика вся WORD и DWORD
        *pd++=*ps++; *pd++=*ps++;      // копируем по 2 байта для скорости
      } while (--len);

      CurrState=EE_START_STAT_WRITE;
      return;
    }

    if (EE_ParamUpdate==EEPROM_PARAM_UPDATE)
    {                                          // обновляем параметры фильтрации
      CurrBase=0;                      // первая копия

      CurrState=EE_START_PARAM_WRITE;
      return;
    }

    EE_StatUpdate=0;                             // сбрасываем некорректные значения
    EE_ParamUpdate=0;
    return;
  }

  if (CurrState==EE_START_STAT_WRITE)            // начинаем обновлять статистику
  {
    CRC16.W=0xFFFF;                    // начальное значение CRC
    EEAddr=(WORD)&EE[CurrBase].Stat;   // адрес в EEPROM
    EESize=sizeof(EEStat);             // кол. байт на запись с учетом CRC
    MemAddr=(BYTE *)&EEStat;           // адрес в памяти откуда пишем

    BYTE tmp=*MemAddr++;
    CRC16.W=_crc16_update(CRC16.W, tmp);

    EEAR=EEAddr;
    EECR |= (1<<EERE);
    if (EEDR!=tmp)
    {
      EEAR=EEAddr;
      EEDR=tmp;
      EECR |= (1<<EEMWE);
      EECR |= (1<<EEWE);
    }

    EEAddr++;
    EESize--;

    CurrState=EE_STAT_WRITE;
    return;
  }

  if (CurrState==EE_STAT_WRITE)                  // продолжаем обновлять статистику
  {
    BYTE tmp=0;

    if (EESize==0)
    {
      CurrBase++;
      if (CurrBase==1)
      {
        CurrState=EE_START_STAT_WRITE; // переходим ко 2 копии
      }
      else
      {
        EE_StatUpdate=0;               // закончили писать статистику
        CurrState=EE_FREE;
      }
      return;
    }

    if (EESize>2)
    {
      tmp=*MemAddr++;
      CRC16.W=_crc16_update(CRC16.W, tmp);
    }
    else
    {
      if (EESize==2) tmp=CRC16.B[0];
      if (EESize==1) tmp=CRC16.B[1];
    }

    EEAR=EEAddr;
    EECR |= (1<<EERE);
    if (EEDR!=tmp)
    {
      EEAR=EEAddr;
      EEDR=tmp;
      EECR |= (1<<EEMWE);
      EECR |= (1<<EEWE);
    }

    EEAddr++;
    EESize--;

    return;
  }


  if (CurrState==EE_START_PARAM_WRITE)           // начинаем обновлять параметры
  {
    CRC16.W=0xFFFF;                    // начальное значение CRC
    EEAddr=(WORD)&EE[CurrBase].Param;  // адрес в EEPROM
    EESize=sizeof(TEEPROMParamBase);   // кол. байта на запись с учетом CRC
    MemAddr=(BYTE *)&modbase.CONFIG;   // адрес в памяти откуда пишем

    BYTE tmp=*MemAddr++;
    CRC16.W=_crc16_update(CRC16.W, tmp);

    EEAR=EEAddr;
    EECR |= (1<<EERE);
    if (EEDR!=tmp)
    {
      EEAR=EEAddr;
      EEDR=tmp;
      EECR |= (1<<EEMWE);
      EECR |= (1<<EEWE);
    }

    EEAddr++;
    EESize--;

    CurrState=EE_PARAM_WRITE;
    return;
  }

  if (CurrState==EE_PARAM_WRITE)                 // продолжаем обновлять параметры
  {
    BYTE tmp=0;

    if (EESize==0)
    {
      CurrBase++;
      if (CurrBase==1)
      {
        CurrState=EE_START_PARAM_WRITE; // переходим ко 2 копии
      }
      else
      {
        EE_ParamUpdate=0;               // закончили писать параметры
        CurrState=EE_FREE;
      }
      return;
    }

    if (EESize>2)
    {
      tmp=*MemAddr++;
      CRC16.W=_crc16_update(CRC16.W, tmp);
    }
    else
    {
      if (EESize==2) tmp=CRC16.B[0];
      if (EESize==1) tmp=CRC16.B[1];
    }

    EEAR=EEAddr;
    EECR |= (1<<EERE);
    if (EEDR!=tmp)
    {
      EEAR=EEAddr;
      EEDR=tmp;
      EECR |= (1<<EEMWE);
      EECR |= (1<<EEWE);
    }

    EEAddr++;
    EESize--;

    return;
  }

  if (CurrState!=EE_FREE) CurrState=EE_FREE;     // если неопределенное состояние, сбрасываем

}

#include <avr/eeprom.h>

//Переменные хранящиеся в EEPROM памяти MCU
uint8_t eeFooByte EEMEM;
uint16_t eeFooWord EEMEM;

int main ( void )
{
    //Переменные для хранения значений из EEPROM в SRAM
    uint8_t myByte;
    uint16_t myWord;

    //Считываем значения из EEPROM
    myByte = eeprom_read_byte(&eeFooByte);
    myWord = eeprom_read_word(&eeFooWord);

    //Записываем новых значения в EEPROM
    if ( myByte == 0х00 ) {
        myByte = 254;
        eeprom_write_byte(&eeFooByte, myByte);
    }
    else {
        myByte = 254;
        eeprom_update_byte(&eeFooByte, myByte);
    }

    if ( myWord == 0х000 ) {
        myWord = 65500;
        eeprom_write_word(&eeFooWord, myWord);
    }
    else {
        myWord = 65500;
        eeprom_update_word(&eeFooWord, myWord);
    }
}