; Write Byte To EEPROM
; --> Acc - byte to write, Z - Address of EEPROM cell
; <-- ничего не возвращает
EEPROM_Write:
    in    SREGM, SREG
    cli
    out   EEARH, ZH
    out   EEARL, ZL
    out   EEDR,  AL
    sbi   EECR,  EEMWE; EE Master Write Enable
    sbi   EECR,  EEWE ; Установить бит 1 в 1 (EE Write Enable)
wait_w:               ; Ждем до завершения записи
    sbic  EECR,  EEWE
    rjmp  wait_w
    cbi   EECR, EEMWE
    out   SREG, SREGM
    ret

Assembly Code Example

EEPROM_write:

; Wait for completion of previous write
sbic EECR,EEWE
rjmp EEPROM_write

; Set up address (r18:r17) in address register
out EEARH, r18
out EEARL, r17

; Write data (r16) to data register
out EEDR,r16

; Write logical one to EEMWE
sbi EECR,EEMWE

; Start eeprom write by setting EEWE
sbi EECR,EEWE
ret


C Code Example

void EEPROM_write(unsigned int uiAddress, unsigned char ucData)
{

/* Wait for completion of previous write */
while(EECR & (1<<EEWE));

/* Set up address and data registers */
EEAR = uiAddress;
EEDR = ucData;

/* Write logical one to EEMWE */
EECR |= (1<<EEMWE);

/* Start eeprom write by setting EEWE */
EECR |= (1<<EEWE);

}

/* файл ee_mgr.c  */
// Использование динамической памяти отбросил (не актуально для мелкоконтроллеров с менее 8k RAM)

#include <avr\io.h>
#include "ee_mgr.h"

#ifndef _ee_mgr_header_present
// объявление возможных ошибок
#define ERROR_MSG_TOO_LONG            0
#define ERROR_BUSY                   -1
#define ERROR_NOT_ENOUGH_FREE_SPACE  -2
// объявление констант
#define EE_BUFFER_LENGTH 16
#endif

#define FALSE 0
#define TRUE 1
#define CARDINAL unsigned char
#define cli asm("cli")
#define EE_ReadyForAction (EECR & (1 << EEWE))


// реализована пока только функции записи в EEPROM,
// чтение по прерыванию сделать нельзя да и было бы медленнее!
char EE_Buf[EE_BUFFER_LENGTH];  // общий буфер для чтения и запис
CARDINAL  EE_CurrentPos = 0;
CARDINAL  EE_Count = 0;
WORD  EE_StartAddress;
char EE_Busy = FALSE;


int EEPROMWriteMsg(WORD address, void *msg, int count)
{
    char *amsg;
    CARDINAL i;
    if (count > EE_BUFFER_LENGTH)
       return ERROR_MSG_TOO_LONG;
    if (EE_Busy)
       return ERROR_BUSY;
    if ((address + count) > E2END)
       return ERROR_NOT_ENOUGH_FREE_SPACE;

    amsg = msg;
    EE_CurrentPos = 0;
    for(i=0; i < count; i++)
       EE_Buf[i] = amsg[i];

    EE_Busy = TRUE;
    EE_Count = count;
    EE_StartAddress = address;
    return count;
}


// апаратно зависимая функция инициализации записи EEPROM
void InitializeEEPROMWriteByte(WORD address, char data)
{
   char sreg_mirror;
   sreg_mirror = SREG;
   cli;
   EEAR = address;
   EEDR = data;
   EECR |= (1 << EEMWE);
   EECR |= (1 << EEWE)|(1 << EERIE);
   SREG = sreg_mirror;
}


// функция для вызова в основном цикле программы
void EEPROMDispatch(void)
{
   char data_byte;
   WORD address;
   if ((!EE_Busy)|(!EE_ReadyForAction))
      return;
   // Запись очередного байта
   if (EE_Count == EE_CurrentPos) // сообщение полностью записано
      {
        EE_Busy = FALSE;
        return;
      }

   data_byte = EE_Buf[EE_CurrentPos];
   address = EE_StartAddress + EE_CurrentPos;
   InitializeEEPROMWriteByte(address, data_byte);
   EE_CurrentPos++;
}

/*   файл ee_mgr.h   */
#define _ee_mgr_header_present
// объем буфера под EEPROM очередь
#define EE_BUFFER_LENGTH 32

#ifdef E2END
  #if (E2END < 0x100)
    #define WORD unsigned char
  #else
    #define WORD short
  #endif
#else
  #define WORD int
#endif

#ifndef EERIE
  #define EERIE 3
#endif

// коды возможных ошибок при обращении к функции записи
#define ERROR_BUSY -1
#define ERROR_NOT_ENOUGH_FREE_SPACE -2
#define ERROR_MSG_TOO_LONG 0


// Макрос, который необходимо вызывать в обработчике прерывания EEPROM_Ready
#define EEPROMReadyHandler     EECR &= ~(1 << EERIE)

void EEPROMDispatch(void);    // функция для вызова в основном цикле программы

int EEPROMWriteMsg(WORD address, void *msg, int count); // запись любых структур

SIGNAL (SIG_EE_READY)
{
   EEPROMReadyHandler;
}


int main( void )
{
  char str[] = "zzz";
  
  EEPROMWriteMsg(0x20, str, sizeof(str));
  
  asm("sei");
  for(;;)
  {
    EEPROMDispatch();
  }
}

__eeprom char State0; // текущее состояние, хранимое в EEPROM

//Считаем состояние из EEPROM и выведем
// в PORTB
  PORTB = State0;