Что такое eeprom память. Как очистить EEPROM (Энергонезависимую память)

Обновлено 16.12.15. Всем привет. Рассмотрев в прошлой статье взаимодействие кнопок с контроллером, в этой записи разберем память МК AVR EEPROM (электрически стираемая ППЗУ), которая является энергонезависимой и имеет ресурс примерно в 100 000 циклов записи/чтения. Зачем нам нужна такая память с ограниченным числом обращений к ней? Такая память идеально подходит для хранения констант и исходных параметров, которые мы можем задать в начале программы, при помощи тех же кнопок.

Следует отметить, что некоторые производители комбинируют память типа EEPROM с SRAM. При прекращении подачи рабочего напряжения содержимое памяти переносится с SRAM в EEPROM, благодаря чему достигают короткого цикла записи не приводящему к износу.

Теперь рассмотрим как обращаться к ней. Для программирования памяти EEPROM используются три регистра, расположенные в области ввода/вывода памяти SRAM: восьмиразрядный регистр адреса EEAR или два регистра EEARH и EEARL; восьмиразрядный регистр данных EEDR; восьмиразрядный регистр управления EECR. когда происходит процесс записи, байт данных адресуется регистром адреса и заносится в регистр данных. В процессе чтения из памяти в регистр данных записывается содержимое ячейки EEPROM, адресуемой регистром адреса.

В книге Евстифеева, справочнике по микроконтроллерам (литературу я приводил в статье №1), описаны программные примеры для записи/чтения. Давайте разберем программу:

Реализация функции записи:

void EEPROM_write (unsigned int uiAddress, unsigned char uoData)
{
while (EECR & (1<
EEAR = uiAddress; //Проинициализировать регистр адреса
EEDR = uoData ; //Проинициализировать регистр данных
EECR |= (1< //Установить флаг EEMWE
EECR |= (1<< EEWE); //Начать запись в EEPROM
}

Разберем программу.
1. EEWE является разрядом регистра (рисунок ниже) EECR и отвечает за разрешение записи в EEPROM, если установлен в 1, то происходит запись в EEPROM , при условии что EEMWE установлен в 1.
2. Загружаем адрес в регистр адреса EEAR

Разряды регистра управления EECR:
EERIE — разрешение прерывания от EEPROM;
EEMWE — управление разрешением записи в EEPROM;
EEWE — разрешение записи в EEPROM;
EERE — разрешение чтения из EEPROM.

3. Загружаем байт данных в регистр данных EEDR.
4. EEMWE – управление разрядом разрешения записи в EEPROM. Этот флаг отвечает за функционирование разряда разрешения записи EEWE. При установке в 1 запись разрешается, если 0, то при установке EEWE в 1 запись в память не произойдет. После программной установки EEMWE сбрасывается через 4 машинных цикла.
5. Записываем данные в память.

Здесь есть один нюанс . Если планируется, периодически записывать данные в EEPROM во время выполнения программы, при самопрограммировании микроконтроллера, то необходимо знать, что запись в EEPROM не может одновременно выполняться с записью во Flash память, поэтому выше после первого пункта необходимо добавить следующий пункт:

— дождаться завершения записи во Flash-память программ, т.е. ждать пока не сброситься флаг SPMEN регистра SPMCR, тогда после этой строки необходимо добавить еще одно циклическое условие:

while (SPMCR &(1<// Завершение записи во Flash память

Теперь разберем функцию чтения:

Unsigned char EEPROM_write (unsigned int uiAddress)
{
while (EECR & (1<//ждем завершения предыдущей записи
EEAR = uiAddress; //Проинициализировать регистр адреса
EECR |= (1<
return EEDR;
}

Здесь все почти также, только в функцию передается адрес переменной, инициализируем его и разрешаем чтение по этому адресу. Возвращаем данные.

Но прежде, чем использовать алгоритм записи или чтения EEPROM, необходимо объявить переменную, которая будет распределена в пределах области EEPROM. Для этого в библиотеке eeprom.h программной среды WinAVR определен специальный атрибут EEMEM. Например объявим переменную без знакового целочисленного типа с атрибутом.

EEMEM uint8_t eeprom_х; // объявим переменную.
х –переменная;
uint8_t – целочисленный без знаковый тип, имеющие точно указанную разрядность, в данном случае 8 бит и предназначен для переносимости программ.
EEMEM – атрибут, заставляющий переменную быть распределенной в пределах раздела.eeprom. Данный атрибут определен в файле eeprom.h и выглядит он следующим образом.

#ifndef EEMEM
#define EEMEM__attribute__ ((section («.eeprom»)))
#endif

Для работы с данными в библиотеке уже прописаны функции:
для чтения
uint8_t eeprom_read_byte (const uint8_t *addr)
Аргументом функций eeprom_read_... является адрес переменной в EEPROM, а результатом — значение переменной в EEPROM.
для записи
void eeprom_write_byte (uint8_t *addr, uint8_t value)
Аргументами функций eeprom_write_... являются адрес в EEPROM, куда записать данные и значение которое нужно записать.

Ну что ж все это пережевав на по следок программный пример в целом. Передадим в EEPROM данные и считаем. Используя AVR и , выведем результат.

#include
#include
#include
#include «lcd.h»

uint8_t EEMEM eepro_х; /* такая переменная должна быть всегда глобальной и служит для передачи своего адреса в область EEPROM*/
char word="Hello";

main ()
{
uint8_t eepro_х1 = 100; /*вторая переменная для передачи данных*/
/*Давайте запишем переменную в память*/
eeprom_write_byte (&eeprom_x, eeprom_x1); /*передаем в функцию адрес переменной и значение которое запишем по этому адресу*/
/*теперь убедимся, что в памяти у нас хранится значение 100, для этого обнулим текущее значение переменной х и присвоим считанное значение из памяти*/
eeprom_х1 = 0;
/*считаем содержимое памяти*/
x1 = eeprom_read_byte (&eeprom_x); // взятие адреса переменной
sprintf (word,"V_eeprom x1=%3d",eeprom_x1);
PrintString (word);
}

Ниже, на рисунке представлен результат
Если в программе изначально передаются какие то константы для хранения в памяти EEPROM, то при прошивке необходимо залить файл с расширением.eep, который будет создан компилятором и размещен в той же директории что и рабочие файлы.

На этом пока все. Здесь дан краткий обзор для работы с такой памятью. Конечно есть куча нюансов, но это уже тонкости. В следующей статье рассмотрим ШИМ (широтно-импульсную модуляцию) и плавно перейдем к следующему проекту попробуем сконструировать «мозги» для любительского станка ЧПУ. Всем пока.

Электрически стираемые программируемые микросхемы постоянной памяти (EEPROM) являются металлическими оксидными полупроводниковыми компьютерными микросхемами, которые используются на печатной плате. Этот тип чипа можно стереть и перепрограммировать с использованием сильного электронного сигнала. Поскольку это можно сделать, не удаляя чип с устройства, к которому он подключен, чипы EEPROM используются во многих отраслях.
Микросхема EEPROM содержит энергонезависимую память, поэтому её данные не теряются при нарушении питания чипа. Микросхема такого типа может быть запрограммирована выборочно, что означает, что часть её памяти может быть изменена с помощью новой перезаписи, не затрагивая остальную память. Информация, хранящаяся внутри микросхемы EEPROM, является постоянной, пока она не будет стёрта или перепрограммирована, что делает её ценным компонентом в компьютерах и других электронных устройствах.

Микросхемы EEPROM созданы на основе транзисторов с плавающим затвором. Микросхема EEPROM запрограммирована путём принудительной программируемой информации в виде электронов через оксид затвора. Затем плавающий затвор обеспечивает хранение этих электронов. Ячейка памяти считается запрограммированной, когда она заряжается электронами, и это представляется нулём. Если ячейка памяти не заряжена, она не запрограммирована, и она представлена единицей.

Для широкого спектра устройств требуется память, поэтому чипы EEPROM имеют множество применений в области бытовой электроники. Они используются в игровых системах, телевизорах и компьютерных мониторах. Слуховые аппараты, цифровые камеры, технология Bluetooth и игровые системы также используют чипы EEPROM. Они используются в телекоммуникационной, медицинской и обрабатывающей промышленности. Персональные и бизнес-компьютеры содержат ЭСППЗУ.

Чип EEPROM также имеет широкий спектр применений в автомобильной отрасли. Он используется в антиблокировочных системах, подушках безопасности, электронных средствах контроля устойчивости, трансмиссиях и блоках управления двигателем. Чипы EEPROM также используются в кондиционерах, дисплеях приборной панели, модулях управления корпусом и системах ввода без ключа. Эти чипы помогают контролировать расход топлива, а также используются в различных диагностических системах.

Существует ограничение на количество повторений, которое может быть перезаписано чипом EEPROM. Слой внутри чипа постепенно повреждается многочисленными переписываниями. Это не большая проблема, потому что некоторые чипы EEPROM могут быть изменены до миллиона раз. Дальнейшие успехи в области технологий, скорее всего, окажут положительное влияние на то, на что могут рассчитывать микросхемы памяти в будущем.

Обнуление памяти EEPROM

Пример циклом проходим по всем ячейкам памяти, и записывает в них нули.

// Подключение библиотеки для работы с EEPROM. #include "EEPROM.h" void setup() { // Проход всех ячеек(байтов) и запись в них нулей. for (int i = 0; i < EEPROM.length(); i++) EEPROM.update(i, 0); } void loop() { // Пустой цикл... }

Откат к заводским настройкам

Если вы хотите вернуть память к заводским настройкам необходимо заменить 0 на 255, т.е. записать не нули, а число 255. Таким образом, в дальнейшем при помощи функции isNaN() возможно проверить была ли произведена запись в память EEPROM или нет.

// Подключение библиотеки для работы с EEPROM. #include "EEPROM.h" void setup() { // Проход всех ячеек(байтов) и запись в них чисел 255. for (int i = 0; i < EEPROM.length(); i++) EEPROM.update(i, 255); } void loop() { // Пустой цикл... }

Расскажи о нас

Сообщение

Если у Вас есть опыт в работе с Arduino и собственно есть время для творчества, мы приглашаем всех желающих стать авторами статей публикуемых на нашем портале. Это могут быть как уроки, так и рассказы о ваших экспериментах с Arduino. Описание различных датчиков и модулей. Советы и наставления начинающим. Пишите и размещайте свои статьи в

Arduino – это целое семейство различных устройств для создания электронных проектов. Микроконтроллеры очень удобны для использования, доступны к освоению даже новичку. Каждый микроконтроллер состоит из платы, программ для обеспечения работы, памяти. В этой статье будет рассмотрена энергонезависимая память, используемая в Arduino.

Описание памяти EEPROM

Ардуино предоставляет своим пользователям три типа встроенной памяти устройств: стационарное ОЗУ (оперативно-запоминающее устройство или SRAM - static random access memory) – необходимо для записи и хранения данных в процессе использования; флеш-карты – для сохранения уже записанных схем; – для хранения и последующего использования данных.

На ОЗУ все данные стираются, как только происходит перезагрузка устройства либо отключается питание. Вторые две сохраняют всю информацию до перезаписи и позволяют извлекать ее при необходимости. Флеш-накопители достаточно распространены в настоящее время. Подробнее стоит рассмотреть память EEPROM.

Аббревиатура расшифровывается, как Electrically Erasable Programmable Read-Only Memory и в переводе на русский дословно означает – электрически стираемая программируемая память только для чтения. Производитель гарантирует сохранность информации на несколько десятилетий вперед после последнего отключения питания (обычно приводят срок в 20 лет, зависит от скорости снижения заряда устройства).

При этом нужно знать, что возможность перезаписи на устройство ограничена и составляет не более 100 000 раз. Поэтому рекомендуют аккуратно и внимательно относиться к вносимым данным и не допускать перезаписи лишний раз.

Объем памяти, в сравнении с современными носителями, очень небольшой и разный для различных микроконтроллеров. Например, для:

ATmega328 – 1кБ
ATmega168 и ATmega8 – 512 байт,
и ATmega1280 – 4 кБ.

Так устроено потому, что каждый микроконтроллер предназначен для определенного объема задач, имеет разное количество выводов для подключения, соответственно, необходим разный объем памяти. При этом такого количества достаточно для обычно создаваемых проектов.

Для записи на EEPROM требуется значительное количество времени – около 3 мс . Если в момент записи отключается питание, данные не сохраняются вовсе либо могут быть записаны ошибочно. Требуется всегда дополнительно проверять внесенную информацию, чтобы избежать сбоев во время работы. Считывание данных происходит гораздо быстрее, ресурс памяти от этого не снижается.

Библиотека

Работа с памятью EEPROM осуществляется с помощью библиотеки, которая была специально создана для Ардуино. Главными являются способность к записи и чтению данных. активируется командой #include EEPROM.h .

для записи – EEPROM.write(address, data);
для чтения – EEPROM.read(address).

В данных скетчах: address – аргумент с данными ячейки, куда вносятся данные второго аргумента data; при считывании используется один аргумент address, который показывает, откуда следует читать информацию.

Функция	Назначение
read(address)	считывает 1 байт из EEPROM ; address – адрес, откуда считываются данные (ячейка, начиная с 0);
write(address, value)	записывает в память значение value (1 байт, число от 0 до 255) по адресу address;
update(address, value)	заменяет значение value по адресу address, если её старое содержимое отличается от нового;
get(address, data)	считывает данные data указанного типа из памяти по адресу address;
put(address, data)	записывает данные data указанного типа в память по адресу address;
EEPROM	позволяет использовать идентификатор "EEPROM" как массив, чтобы записывать данные в память и считывать их из памяти.

Запись целых чисел

Запись целых чисел в энергонезависимую память EEPROM осуществить достаточно просто. Внесение чисел происходит с запуском функции EEPROM.write() . В скобках указываются необходимые данные. При этом числа от 0 до 255 и числа свыше 255 записываются по-разному. Первые вносятся просто – их объем занимает 1 байт, то есть одну ячейку. Для записи вторых необходимо использовать операторов highByte() высший байт и lowByte() низший байт.

Число делится на байты и записывается отдельно по ячейкам. Например, число 789 запишется в две ячейки: в первую пойдет множитель 3, а во вторую – недостающее значение. В итоге получается необходимое значение:

3 * 256 + 21 = 789

Для « воссоединения» большого целого числа применяется функция word(): int val = word(hi, low) . Нужно читывать, что максимальное целое число для записи – 65536 (то есть 2 в степени 16). В ячейках, в которых еще не было иных записей, на мониторе будут стоять цифры 255 в каждой.

Запись чисел с плавающей запятой и строк

Числа с плавающей запятой и строк – это форма записи действительных чисел, где они представляются из мантиссы и показателя степени. Запись таких чисел в энергонезависимую память EEPROM производится с активацией функции EEPROM.put() , считывание, соответственно, – EEPROM.get() .

При программировании числовые значения с плавающей запятой обозначаются, как float, стоит отметить, что это не команда, а именно число. Тип Char (символьный тип) – используется для обозначения строк. Процесс записи чисел на мониторе запускается при помощи setup(), считывание – с помощью loop().

В процессе на экране монитора могут появиться значения ovf, что значит «переполнено», и nan, что значит «отсутствует числовое значение». Это говорит о том, что записанная в ячейку информация не может быть воспроизведена, как число с плавающей точкой. Такой ситуации не возникнет, если достоверно знать, в какой ячейке какой тип информации записан.

Примеры проектов и скетчей

Пример №1

Скетч запишет до 16 символов с последовательного порта и в цикле выведет 16 символов из EEPROM. Благодаря данные записываются в EEPROM и контролируется содержимое энергонезависимой памяти.

// проверка работы EEPROM #include int i, d; void setup() { Serial.begin(9600); // инициализируем порт, скорость 9600 } void loop() { // чтение EEPROM и вывод 16 данных в последовательный порт Serial.println(); Serial.print("EEPROM= "); i= 0; while(i < 16) { Serial.print((char)EEPROM.read(i)); i++; } // проверка есть ли данные для записи if (Serial.available() != 0) { delay(50); // ожидание окончания приема данных // запись в EEPROM i= 0; while(i < 20) { d= Serial.read(); if (d == -1) d= " "; // если символы закончились, заполнение пробелами EEPROM.write(i, (byte)d); // запись EEPROM i++; } } delay(500); }

Пример №2

Для большего понимания мы можем создать небольшой скетч, который поможет в понимании работы с энергонезависимой памятью. Считаем все ячейки этой памяти. Если ячейка не пустая - вывод в последовательный порт. После чего заполняем ячейки пробелами. Потом вводим текст через монитор последовательного порта. Его записываем в EEPROM, и при последующем включении считываем.

#include int address = 0; // адрес eeprom int read_value = 0; // считываемые с eeprom данные char serial_in_data; // данные последовательного порта int led = 6; // линия 6 для светодиода int i; void setup() { pinMode(led, OUTPUT); // линия 6 настраивается на выход Serial.begin(9600); // скорость передачи по последовательному порту 9600 Serial.println(); Serial.println("PREVIOUS TEXT IN EEPROM:-"); for(address = 0; address < 1024; address ++) // считываем всю память EEPROM { read_value = EEPROM.read(address); Serial.write(read_value); } Serial.println(); Serial.println("WRITE THE NEW TEXT: "); for(address = 0; address < 1024; address ++) // заполняем всю память EEPROM пробелами EEPROM.write(address, " "); for(address = 0; address < 1024;) // записываем пришедшие с последовательного порта данные в память EEPROM { if(Serial.available()) { serial_in_data = Serial.read(); Serial.write(serial_in_data); EEPROM.write(address, serial_in_data); address ++; digitalWrite(led, HIGH); delay(100); digitalWrite(led, LOW); } } } void loop() { //---- мигаем светодиодом каждую секунду -----// digitalWrite(led, HIGH); delay(1000); digitalWrite(led, LOW); delay(1000); }

Пример №3

Запись в память два целых числа, чтение их из EEPROM и вывод в последовательный порт. Числа от 0 до 255 занимают 1 байт памяти, с помощью функции EEPROM.write() записываются в нужную ячейку. Для чисел больше 255 их нужно делить на байты с помощью highByte() и lowByte() и записывать каждый байт в свою ячейку. Максимальное число при этом – 65536 (или 2 16).

#include // подключаем библиотеку EEPROM void setup() { int smallNum = 123; // целое число от 0 до 255 EEPROM.write(0, smallNum); // запись числа в ячейку 0 int bigNum = 789; // число > 255 разбиваем на 2 байта (макс. 65536) byte hi = highByte(bigNum); // старший байт byte low = lowByte(bigNum); // младший байт EEPROM.write(1, hi); // записываем в ячейку 1 старший байт EEPROM.write(2, low); // записываем в ячейку 2 младший байт Serial.begin(9600); // инициализация послед. порта } void loop() { for (int addr=0; addr<1024; addr++) { // для всех ячеек памяти (для Arduino UNO 1024) byte val = EEPROM.read(addr); // считываем 1 байт по адресу ячейки Serial.print(addr); // выводим адрес в послед. порт Serial.print("\t"); // табуляция Serial.println(val); // выводим значение в послед. порт } delay(60000); // задержка 1 мин }

Пример №4

Запись чисел с плавающей запятой и строк - метод EEPROM.put() . Чтение – EEPROM.get() .

#include // подключаем библиотеку void setup() { int addr = 0; // адрес float f = 3.1415926f; // число с плавающей точкой (типа float) EEPROM.put(addr, f); // записали число f по адресу addr addr += sizeof(float); // вычисляем следующую свободную ячейку памяти char name = "Hello, SolTau.ru!"; // создаём массив символов EEPROM.put(addr, name); // записываем массив в EEPROM Serial.begin(9600); // инициализация послед. порта } void loop() { for (int addr=0; addr<1024; addr++) { // для всех ячеек памяти (1024Б=1кБ) Serial.print(addr); // выводим адрес в послед. порт Serial.print("\t"); // табуляция float f; // переменная для хранения значений типа float EEPROM.get(addr, f); // получаем значение типа float по адресу addr Serial.print(f, 5); // выводим с точностью 5 знаков после запятой Serial.print("\t"); // табуляция char c; // переменная для хранения массива из 20 символов EEPROM.get(addr, c); // считываем массив символов по адресу addr Serial.println(c); // выводим массив в порт } delay(60000); // ждём 1 минуту }

Пример №5

Использование EEPROM как массива.

#include void setup() { EEPROM = 11; // записываем 1-ю ячейку EEPROM = 121; // записываем 2-ю ячейку EEPROM = 141; // записываем 3-ю ячейку EEPROM = 236; // записываем 4-ю ячейку Serial.begin(9600); } void loop() { for (int addr=0; addr<1024; addr++) { Serial.print(addr); Serial.print("\t"); int n = EEPROM; // считываем ячейку по адресу addr Serial.println(n); // выводим в порт } delay(60000); }

Работа с EEPROM

Как упоминалось ранее, ресурс памяти EEPROM ограничен. Для продления срока службы энергонезависимой памяти, вместо функции write() запись, лучше применять функцию update обновление. При этом перезапись ведется только для тех ячеек, где значение отличается от вновь записываемого.

Еще одной полезной функцией рассматриваемой памяти микроконтроллера является возможность использования ячеек хранения байтов, как деталей целостного массива EEPROM. При любом формате использования необходимо постоянно осуществлять контроль целостности записанных данных.

Такая память на Ардуино стандартно хранит самое важное для работы контроллера и устройства. К примеру, если на такой базе создается регулятор температуры и исходные данные окажутся ошибочными, устройство будет работать «неадекватно» существующим условиям – сильно занижать или завышать температуру.

Существует несколько ситуаций, когда память EEPROM содержит неправильные данные:

При первоначальной активации – еще не было ни одной записи.
В момент неконтролируемого отключения питания – часть или все данные не запишутся или запишутся некорректно.
После завершения возможных циклов перезаписи данных.

Чтобы избежать возникновения неприятных последствий, устройство можно запрограммировать на несколько вариантов действий: применить данные аварийного кода, отключить систему полностью, подать сигнал о неисправности, использовать заранее созданную копию или другие.

Для контроля целостности информации используют контрольный код системы. Он создается по образцу записи первоначальных данных и, при проверке, он вновь просчитывает данные. Если результат отличается – это ошибка. Самым распространенным вариантом такой проверки является контрольная сумма – выполняется обычная математическая операция по сложению всех значений ячеек.

Опытные программисты добавляют к этому коду дополнительное «исключающее ИЛИ», например, E5h. В случае если все значения равны нулю, а система по ошибке обнулила исходные данные – такая хитрость выявит ошибку.

Таковы основные принципы работы с энергонезависимой памятью EEPROM для микроконтроллеров Arduino. Для определенных проектов стоит использовать только этот вид памяти. Он имеет как свои плюсы, так и свои недостатки. Для освоения методов записи и чтения лучше начать с простых задач.

Наш контроллер печи почти готов – однако пока он остаётся контроллером-«золотой рыбкой», который помнит все настройки только пять минут до первого выключения питания. Чтобы запомнить наши настройки, значение заданной температуры и точки калибровки даже после отключения питания, нужно использовать энергонезависимую память – EEPROM.
Очень хорошо о работе с EEPROM написано у наших товарищей и .

Главное, что нам нужно знать – что память EEPROM лучше рассматривать не как «просто память», а как отдельное внутреннее устройство в микросхеме.
У EEPROM отдельное адресное пространство , не имеющее никакого отношения к адресному пространству процессора (FLASH и SRAM); для того, чтобы получить доступ к данным по определённому адресу в энергонезависимой памяти, нужно выполнить определённую последовательность действий с использованием целого ряда регистров (регистров адреса EEARH и EEARL, регистра данных EEDR и регистра управления EECR).
Согласно даташиту, для записи байта по определённому адресу в EEPROM нужно выполнить следующее:

ждём готовности EEPROM к записи данных (сброса бита EEPE регистра EECR);
ждём окончания записи в FLASH-память (сброса бита SELFPRGEN регистра SPMCSR) – нужно выполнить, если в программе присутствует загрузчик;
записываем новый адрес в регистр EEAR (при необходимости);
записываем байт данных в регистр EEDR (при необходимости);
устанавливаем в единицу бит EEMPE регистра EECR;
в течение четырёх тактов после установки флага EEMPE записываем в бит EEPE регистра EECR логическую единицу.

После этого процессор пропускает 2 такта перед выполнением следующей инструкции.
Второй пункт нужно выполнять при наличии загрузчика в программе – дело в том, что запись в EEPROM не может выполняться одновременно с записью во FLASH-память, поэтому перед записью в EEPROM нужно убедиться, что программирование FLASH-памяти завершено; если же микроконтроллер не имеет загрузчика, то он никогда не изменяет содержимое FLASH-памяти (помним, что avr имеет гарвардскую архитектуру: память программ (FLASH) и память данных (SRAM) разделены).
Длительность цикла записи зависит от частоты внутреннего RC-генератора микросхемы, напряжения питания и температуры; обычно для моделей ATmega48x/88x/168x это составляет 3.4 мс (!), для некоторых старых моделей – 8.5 мс (!!!).
Кроме того, при записи в EEPROM могут возникнуть проблемы с вызовом прерываний в процессе выполнения последовательности действий выше – так что прерывания в процессе записи в EEPROM лучше запретить.
Чтение энергонезависимой памяти происходит чуть проще:

ждём готовности EEPROM к чтению данных (сброса бита EEWE регистра EECR);
записываем адрес в регистр EEAR;
устанавливаем в единицу бит EERE регистра EECR;
считываем данные из регистра EEDR (на самом деле, когда запрошенные данные будут перемещены в регистр данных, происходит аппаратный сброс бита EERE; но отслеживать состояние этого бита не требуется, так как операция чтения из EEPROM всегда выполняется за один такт).

После установки бита в EERE в единицу процессор пропускает 4 такта перед началом выполнения следующей инструкции.
Как мы видим, работа с энергонезависимой памятью – процесс времязатратный; если мы часто будем записывать-считывать данные с EEPROM – программа может начать тормозить.

Однако мы пишем программу в среде IAR, и нам повезло: всю работу с чтением-записью из EEPROM будет выполнять среда разработки – в iar есть модификатор «__eeprom», который создает переменные в энергонезависимой памяти – а далее нам нужно будет просто или считывать из «постоянных» переменных в «текущие» (при инициализации контроллера), или записывать из «текущих» переменных в «постоянные» – то есть, при изменении текущего значения нужно изменять и значение переменной в энергонезависимой памяти.
Выглядеть новые переменные будут вот так:

Eeprom uint16_t EEP_MinTemperature;

Ещё пару общих слов: и хотя указатели на eeprom-переменные у нас не предполагаются, нужно помнить, что eeprom – отдельное адресное пространство, и чтобы создать указатель на eeprom (и это позволяет нам сделать компилятор), необходимо указывать, что это указатель на адрес в eeprom:

Uint16_t __eeprom *EEP_MinTemperatureAdr;

Возвращаемся к контроллеру печки и EEPROM. В нашем случае, для EEPROM никакой виртуальной машины, конечно, не предполагается; более того, стоит подумать, нужна ли отдельная библиотека для работы с энергонезависимой памятью – уж больно «разбросаны» по программе записи важных настроек; если пытаться сделать отдельную библиотеку, то придётся делать перекрестные ссылки: в библиотеке для EEPROM подключать библиотеки АЦП, нагревательного элемента, глобальных настроек; а в этих библиотеках периферии подключать библиотеку EEPROM – такой подход не очень хорош.
Другой вариант – дописать в каждую библиотеку, где нужно сохранять настройки, eeprom-переменную, и сохранять соответствующие настройки прямо в виртуальных машинах. Мы реализуем этот вариант.
Сначала перечислим, какие переменные нам нужно сохранять в EEPROM:

точки калибровки
значения максимальной-минимальной задаваемой температуры и шага настройки температуры
значение заданной температуры
коэффициенты ПИД-регулятора

Значение кухонного таймера не сохраняем – будем считать, что пользователь после выключения питания должен сам каждый раз настраивать таймер печки.
Все эти настройки задаются пользователем посредством поворотов энкодера и дальнейшего краткого нажатия на пользовательскую кнопку. При этом помним, что количество циклов чтения-записи EEPROM все-таки ограничено, поэтому лишний раз одну и ту же информацию (например, если пользователь выбрал то же самое значение какой-то настройки, что и было) не перезаписывать. Поэтому перед каждым изменением __eeprom-переменной проверяем, а нужно ли её переписывать:

//если значение изменилось - перезаписываем в энергонезависимой памяти if (ADCTemperature.atMinTemperatureValue != (uint16_t)VMEncoderCounter.ecntValue) { ADCTemperature.atMinTemperatureValue = (uint16_t)VMEncoderCounter.ecntValue; EEP_MinTemperature = ADCTemperature.atMinTemperatureValue; }

С чтением настроек из EEPROM тоже все просто – при инициализации «текущих» настроек мы просто считываем значение из энергонезависимой памяти:

ADCTemperature.atMinTemperatureValue = EEP_MinTemperature;

Для того, чтобы наше устройство с самого начала имело какие-нибудь настройки в EEPROM, проект для первой загрузки можно скомпилировать с инициализацией этих переменных:

Eeprom uint16_t EEP_MinTemperature = 20; … //массив для хранения точек калибровки в энергонезависимой памяти __eeprom TCalibrationData EEP_CalibrationData = {{20, 1300}, {300, 4092}};

В этом случае компилятор инициализирует __eeprom переменные до начала работы с основной функцией. Чтобы получить файл с энергонезависимой памятью (.eep), нужно залезть в следующие настройки:
Project->Options..->Linker->Extra Options
Если галочка «Use command line options» не стоит, поставьте её и добавьте строку
-Ointel-standard,(XDATA)=.eep
Компилируем сначала проект с инициализированными переменными, сохраняем eep-файл отдельно; затем убираем инициализацию при создании переменных.

Вот и все – наша печка готова!