инициализация eeprom что это
Arduino EEPROM энергонезависимая память
Ардуино предоставляет своим пользователям три типа встроенной памяти устройств и одна из них EEPROM – энергонезависимая память.
Описание памяти EEPROM
Arduino – это целое семейство различных устройств для создания электронных проектов. Микроконтроллеры очень удобны для использования, доступны к освоению даже новичку. Каждый микроконтроллер состоит из платы, программ для обеспечения работы, памяти. В этой статье будет рассмотрена энергонезависимая память, используемая в Arduino.
Ардуино предоставляет своим пользователям три типа встроенной памяти устройств: стационарное ОЗУ (оперативно-запоминающее устройство или SRAM — static random access memory) – необходимо для записи и хранения данных в процессе использования; флеш-карты – для сохранения уже записанных схем; EEPROM – для хранения и последующего использования данных.
На ОЗУ все данные стираются, как только происходит перезагрузка устройства либо отключается питание. Вторые две сохраняют всю информацию до перезаписи и позволяют извлекать ее при необходимости. Флеш-накопители достаточно распространены в настоящее время. Подробнее стоит рассмотреть память EEPROM.
Аббревиатура расшифровывается, как Electrically Erasable Programmable Read-Only Memory и в переводе на русский дословно означает – электрически стираемая программируемая память только для чтения. Производитель гарантирует сохранность информации на несколько десятилетий вперед после последнего отключения питания (обычно приводят срок в 20 лет, зависит от скорости снижения заряда устройства).
При этом нужно знать, что возможность перезаписи на устройство ограничена и составляет не более 100 000 раз. Поэтому рекомендуют аккуратно и внимательно относиться к вносимым данным и не допускать перезаписи лишний раз.
Объем памяти, в сравнении с современными носителями, очень небольшой и разный для различных микроконтроллеров. Например, для:
Так устроено потому, что каждый микроконтроллер предназначен для определенного объема задач, имеет разное количество выводов для подключения, соответственно, необходим разный объем памяти. При этом такого количества достаточно для обычно создаваемых проектов.
Для записи на EEPROM требуется значительное количество времени – около 3 мс. Если в момент записи отключается питание, данные не сохраняются вовсе либо могут быть записаны ошибочно. Требуется всегда дополнительно проверять внесенную информацию, чтобы избежать сбоев во время работы. Считывание данных происходит гораздо быстрее, ресурс памяти от этого не снижается.
Библиотека
Работа с памятью EEPROM осуществляется с помощью библиотеки, которая была специально создана для Ардуино. Главными являются способность к записи и чтению данных. Библиотека активируется командой #include EEPROM.h.
Далее используются простые команды:
В данных скетчах: address – аргумент с данными ячейки, куда вносятся данные второго аргумента data; при считывании используется один аргумент address, который показывает, откуда следует читать информацию.
Запись целых чисел
Запись целых чисел в энергонезависимую память EEPROM осуществить достаточно просто. Внесение чисел происходит с запуском функции EEPROM.write(). В скобках указываются необходимые данные. При этом числа от 0 до 255 и числа свыше 255 записываются по-разному. Первые вносятся просто – их объем занимает 1 байт, то есть одну ячейку. Для записи вторых необходимо использовать операторов highByte() высший байт и lowByte() низший байт.
Число делится на байты и записывается отдельно по ячейкам. Например, число 789 запишется в две ячейки: в первую пойдет множитель 3, а во вторую – недостающее значение. В итоге получается необходимое значение:
Для «воссоединения» большого целого числа применяется функция 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. Благодаря Arduino IDE данные записываются в EEPROM и контролируется содержимое энергонезависимой памяти.
Пример №2
Пример №3
Запись в память два целых числа, чтение их из EEPROM и вывод в последовательный порт. Числа от 0 до 255 занимают 1 байт памяти, с помощью функции EEPROM.write() записываются в нужную ячейку. Для чисел больше 255 их нужно делить на байты с помощью highByte() и lowByte() и записывать каждый байт в свою ячейку. Максимальное число при этом – 65536 (или 2 16 ).
Пример №4
Пример №5
Использование EEPROM как массива.
Работа с EEPROM
Как упоминалось ранее, ресурс памяти EEPROM ограничен. Для продления срока службы энергонезависимой памяти, вместо функции write() запись, лучше применять функцию update обновление. При этом перезапись ведется только для тех ячеек, где значение отличается от вновь записываемого.
Еще одной полезной функцией рассматриваемой памяти микроконтроллера является возможность использования ячеек хранения байтов, как деталей целостного массива EEPROM. При любом формате использования необходимо постоянно осуществлять контроль целостности записанных данных.
Такая память на Ардуино стандартно хранит самое важное для работы контроллера и устройства. К примеру, если на такой базе создается регулятор температуры и исходные данные окажутся ошибочными, устройство будет работать «неадекватно» существующим условиям – сильно занижать или завышать температуру.
Существует несколько ситуаций, когда память EEPROM содержит неправильные данные:
Чтобы избежать возникновения неприятных последствий, устройство можно запрограммировать на несколько вариантов действий: применить данные аварийного кода, отключить систему полностью, подать сигнал о неисправности, использовать заранее созданную копию или другие.
Для контроля целостности информации используют контрольный код системы. Он создается по образцу записи первоначальных данных и, при проверке, он вновь просчитывает данные. Если результат отличается – это ошибка. Самым распространенным вариантом такой проверки является контрольная сумма – выполняется обычная математическая операция по сложению всех значений ячеек.
Опытные программисты добавляют к этому коду дополнительное «исключающее ИЛИ», например, E5h. В случае если все значения равны нулю, а система по ошибке обнулила исходные данные – такая хитрость выявит ошибку.
Таковы основные принципы работы с энергонезависимой памятью EEPROM для микроконтроллеров Arduino. Для определенных проектов стоит использовать только этот вид памяти. Он имеет как свои плюсы, так и свои недостатки. Для освоения методов записи и чтения лучше начать с простых задач.
Arduino: EEPROM — работа с энергонезависимой памятью
Подробно о памяти можно почитать на официальном ресурсе — http://playground.arduino.cc/Learning/Memory.
EEPROM ( англ. Electrically Erasable Programmable Read-Only Memory) — электрически стираемое перепрограммируемое ПЗУ ( ЭСППЗУ), один из видов энергонезависимой памяти.
Объемы памяти для каждого из чипов различны:
| ATmega168 | ATmega328 | ATmega1280 | ATmega2560 | |
| Flash (1 кБ flash-памяти занят загрузчиком) | 16 Кбайт | 32 Кбайт | 128 Кбайт | 256 Кбайт |
| SRAM | 1 Кбайт | 2 Кбайт | 8 Кбайт | 8 Кбайт |
| EEPROM | 512 байт | 1024 байта | 4 Кбайт | 4 Кбайт |
Память EEPROM, по заявлениям производителя, обладает гарантированным жизненным циклом 100 000 операций записи/стирания и 100 лет хранения данных при температуре 25°С. Эти данные не распространяются на операции чтения данных из EEPROM — чтение данных не лимитировано. Исходя из этого, нужно проектировать свои скетчи максимально щадящими по отношению к EEPROM.
Время затраченное на одну операцию записи в EEPROM составляет примерно 3,3 мс.
Доступ к EEPROM организован таким образом, что пользователь имеет возможность манипулировать каждым отдельным байтом памяти.
Каждый байт EEPROM по умолчанию ( ни разу не записанный) имеет значение 255.
Библиотека EEPROM.h предоставляет доступ к основным функциям по работе с EEPROM:
| Функция | Описание |
| read() | EEPROM.read(address) Считывает один байт из EEPROM по адресу address. Значение ячейки, по умолчанию, 255. |
Записывает один байт со значением value в EEPROM по адресу address.
Позволяет обращаться с байтами EEPROM как с массивом байтов. Байты можно считывать и записывать.
Операции чтения и записи данных с типом byte ( диапазон значений 0-255) очень просты:
Поскольку память EEPROM имеет ограниченный жизненный цикл, вместо функции записи write() предпочтительнее использовать функцию обновления значения update() — она осуществляет запись, только в случае отличия нового значения от существующего:
Пример записи/чтения значения типа float :
При чтении данных типа пользовательской структуры, если данные не были записаны ранее, будут получены неприемлемые данные:
Пример записи и чтения пользовательских структур:
Контроль целостности данных
Возможность использования объекта EEPROM[] как массива данных, бывает востребована для задач связанных с контролем целостности данных. Контроль целостности данных заключается в расчете контрольной суммы CRC — отпечатка состояния EEPROM, и в дальнейшем сравнении эталонного отпечатка с отпечатком, полученным из актуального состояния EEPROM. В случае несовпадения отпечатков можно однозначно делать вывод о нарушении целостности памяти и запускать заранее подготовленную реакцию на эту ситуацию.
Для ускорения вычисления CRC используется таблица с заранее просчитанными « магическими» числами:
ПРОГРАММИРОВАНИЕ МИКРОКОНТРОЛЛЕРОВ: ЕЕПРОМ
Забросил я уроки для начинающих, сегодня поговорим о EEPROM — энергонезависимой памяти.
Эта память одно из главных составляющих в функционале поделок на микроконтроллерах, любой начинающий микроконтроллерщик подходит к этапу освоения этой энергонезависимой памяти. Оно и ежу понятно, что сохранять настройки очень часто надо, нужно и без этого нельзя.
В даташитах все рассусолено сухим техническим языком про особенности работы еепром, я же остановлюсь на основополагающих правилах использования этой памяти, правильную на мой взгляд.
Объявляется еепром так же как и переменная, работают с еепром так же как с переменной, кроме некоторых но. Пример (Code Vision AVR):
unsigned char a; // объявляем беззнаковую переменную размером 8 бит
unsigned char eeprom eea; // объявляем «переменную» в еепром такого же типа, этого достаточно, всю остальную работу делает компилятор.
Переменную я обозвал в кавычках, ибо с ней можно обращаться как с обычной переменной, а в остальном она ведет себя по другому:
1. — значение хранимое в ЕЕПРОМ по умолчанию равно максимально возможному числу, в нашем случае после объявления в eea лежит число 255 или оно же 0xFF или оно же 0b11111111.
2- количество циклов стирания-записи у памяти ЕЕПРОМ относительно мало, поэтому нужно максимально ограничивать число записей в алгоритме программы.
Вот поучительная история про то, как фирма BLAUPUNKT лоханулась и проигнорировала второй пункт: www.audi.org.ua/materials/2954.html
3. Память ЕЕПРОМ самый тормозной тип данных, это нужно учитывать. Особенно при записи в ЕЕПРОМ. Можно получить каку, например, запихнув обработку еепром в прерываниях. В особо ответственных моментах можно использовать флаги состояния памяти ЕЕПРОМ, бывает очень полезно.
После обявления еепром и переменной я делаю команду присвоения числа из еепром в переменную, до начала основного цикла и как правило до начала работы прерываний:
После этого я верчу как хочу эту переменную, пишу в нее, читаю, используя ее в алгоритме и в нужный момент, когда нужно сохранить делаю так, чтоб данные закатились из этой переменной обратно в ЕЕПРОМ единожды:
Вот пример куска кода записи в ЕЕПРОМ:
unsigned char a; // объявляем беззнаковую переменную размером 8 бит
unsigned char eeprom eea; // объявляем еепром такого же типа,
unsigned char trig; // объявляем переменную, которая будет помнить, что кнопка нажата.
Далее идет основанная часть программы void main(void), в ней :
a=eea; // загоняем данные в с еепром в переменную
Далее идет главный цикл while(1) и в теле цикла:
if(key==1) // если кнопка настройки нажата, то:
<
trig=1; // включаем триггер, который запоминает, что кнопка нажата
a*b+b^2 ; //тут что то делаем нужное, когда кнопка нажата
>
else // если кнопка отжата
<
LED=1 ; //тут что то делаем нужное, когда кнопка отжата
if(trig) //если кнопка отжата и триггер включен, то:
<
eea=a; // пишем переменную а в еепром
trig=0; // сбрасываем триггер
>
>
Запись в ЕЕПРОМ срабатывает по отжатию кнопки единожды, когда триггер равен единице.
Электроника для всех
Блог о электронике
AVR. Учебный Курс. Использование EEPROM
Иногда нужно сохранить данные так, чтобы они восстановились после перезагрузки контроллера. В этом тебе поможет EEPROM, почти все контроллеры серии AVR имеют на борту некоторое количество этой памяти. Физически и логически эта память находится в отдельном адресном пространстве, а чтение из EEPROM и запись туда осуществляется через специальные порты.
Чтобы что-то записать в EEPROM нужно в регистры адреса EEARH и EEARL (EEPROM Address Register) положить адрес ячейки в которую мы хотим записать байт. После чего нужно дождаться готовности памяти к записи – EEPROM довольно медленная штука. О готовности к записи нам доложит флаг EEWE (EEPROM Write Enable) регистра управления состоянием EECR, когда он будет равен 0, то память готова к следующей записи. Сам байт, который нужно записать, помещается в регистр EEDR (EEPROM Data Register). После чего взводится предохранительный бит EEMWE (EEPROM Master Write Enable), а затем, в течении четырех тактов, нужно установить бит EEWE и байт будет записан. Если в течении четырех тактов не успеешь выставить бит EEWE то предохранительный бит EEMWE сбросится и его придется выставлять снова. Это сделано для защиты от случайной записи в EEPROM память.
Вот так выглядит запись в память:
… LDI R16,0 ; Загружаем адрес нулевой ячейки LDI R17,0 ; EEPROM LDI R21,45 ; и хотим записать в нее число 45 RCALL EEWrite ; вызываем процедуру записи.
LDI R16,0 ; Загружаем адрес нулевой ячейки LDI R17,0 ; EEPROM из которой хотим прочитать байт RCALL EERead ; вызываем процедуру чтения. После которой ; в R21 будет считанный байт.
Ну и, разумеется, сами процедуры чтения и записи
EEWrite: SBIC EECR,EEWE ; Ждем готовности памяти к записи. Крутимся в цикле RJMP EEWrite ; до тех пор пока не очистится флаг EEWE CLI ; Затем запрещаем прерывания. OUT EEARL,R16 ; Загружаем адрес нужной ячейки OUT EEARH,R17 ; старший и младший байт адреса OUT EEDR,R21 ; и сами данные, которые нам нужно загрузить SBI EECR,EEMWE ; взводим предохранитель SBI EECR,EEWE ; записываем байт SEI ; разрешаем прерывания RET ; возврат из процедуры EERead: SBIC EECR,EEWE ; Ждем пока будет завершена прошлая запись. RJMP EERead ; также крутимся в цикле. OUT EEARL, R16 ; загружаем адрес нужной ячейки OUT EEARH, R17 ; его старшие и младшие байты SBI EECR,EERE ; Выставляем бит чтения IN R21, EEDR ; Забираем из регистра данных результат RET
Да, при работе с EEPROM нужно в цикле ожидания готовности не забывать командой WDR сбрасывать Watch Dog Timer — специальный сторожевой таймер, отслеживающий зависание процессора. Если его не сбрасывать с нужной периодичностью, то он сбрасывает контроллер. Это, конечно, если Watch Dog используется. По дефолту он вырублен. Но помнить надо, иначе огребете трудно отслеживаемый глюк.
Впрочем, у EEPROM тоже есть свои прерывания. Это:
И никто не помешает выбросить цикл ожидания и сделать массовую запись в ЕЕПРОМ на прерываниях! Аналогично как это сделано для USART. А если надо что то сохранить очень быстро, то можно и буферизированную с пробросом через RAM таким же образом запись заюзать. Т.е. сначала быстро сожрали в оперативку, а потом, неспеша, по прерываниям, загнать в EEPROM.
Спасибо. Вы потрясающие! Всего за месяц мы собрали нужную сумму в 500000 на хоккейную коробку для детского дома Аистенок. Из которых 125000+ было от вас, читателей EasyElectronics. Были даже переводы на 25000+ и просто поток платежей на 251 рубль. Это невероятно круто. Сейчас идет заключение договора и подготовка к строительству!
А я встрял на три года, как минимум, ежемесячной пахоты над статьями :)))))))))))) Спасибо вам за такой мощный пинок.
135 thoughts on “AVR. Учебный Курс. Использование EEPROM”
Спасибо! Отличная статья! Как раз сейчас нужно будет использовать EEPROM. Конечно можно прочитать даташит, что я обычно и делаю, но там все довольно разбросано, а здесь раз прочитал и в голове сложилась четкая структура.
P.S. Еще интересно, может у тебя уже был опыт по использованию карт памяти SD/MMC? Там же вроде элементарно по SPI с ними общаться.
До SPI пока руки не доходили. А так да, в планах. С этими карточками проблема составляет не SPI доступ, а FAT 🙂
Впринципе туда можно любую файловую систему зарулить. Хоть Fat, хоть Ext2fs, хоть вобще BSD’шную файловую систему.
А описаний и документации, как работать с этими системами хоть отбавляй!
Хочу использовать SD катрочку в автомобильном логгере (запись показаний датчиков системы впрыска)
Забыл написать, что у атмеловских контроллеров есть так называемая «мертвая зона» EEPROM-a. У 64й атмеги, например, это все адреса от 0x00 — 0x100. Так же была замечена тенденция (по крайней мере на атмегах), чем круче модель (ATMeag32->64->128), тем больше у нее мертвая зона EEPROM. Причем в документации, про нее нифига не написано и подбирать придется в ручную. Ах да, чем же она такая мертвая эта зона. А тем, что запись и чтение в ней происходят через раз, а то и не происходят вообще. Дрочится конечно можно, но лучше оставить эти 100 адресов на советси разработчиков и работать со стабильным ПЗУ.
Может это контроллеры бракованные были? Или может запись производилась без проверки готовности EEPROM’а?
Нет, контроллеры н бракованные и запись проводилась так как нужно, будь уверен.
День добрый!
Ребята, вы все занимаетесь электроникой, помогите решить задачу, пожалуйста.
Для вас это не составит труда, а человеку поможете.
Задание:
Разработать систему измерения частоты и скважности сигнала с ТТЛ – совместимыми уровнями и вывод результата на индикатор МТ-16S2х (частота – верхняя строка, скважность — нижняя). Диапазон измеряемых частот — 1÷1000 Гц. Абсолютный шаг измерения скважности – не менее 0,1 мс. Период накопления данных при измерении частоты – 1 секунда.
ядро м/п системы:
ATMEGA-8, ATTINY2313 (AVR)
Нужны:
расчетные параметры устройств (адреса, режимы работы и.т.д.),
принципиальную электрическую схему системы,
блок-схему программы, программу на языке ассемблера.
Помогите пожалуйста, я не понимаю в этом ничего. А вам может будет интересно.
Зарание спасибо.
Не, нам это не интересно уже. Если будут _конкретные_ вопросы, на которые можно будет дать четкий ответ, то задавай.
Я бы с радостью задала вопрос, но я в этом ничего не понимаю.
Это в институт надо принести, я студентка.
Дали такое задание.
Помогите пожалуйста.
Я могу заплатить за работу.
Просто очень надо, мне больше не к кому обратится.
Я догадался.
Ну что я могу сказать. Вы, похоже, сильно ошиблись специальностью, мне вас искренне жаль. В таком случае ничем помочь не могу. Если кто из комментов откликнется, то может быть вам повезет.
З.Ы. Студия тоже не фонтан… Сменил в простеньком проекте мегу8 на мегу 32 — так студия перестала показывать состояние всех РВВ… Создал пустой проект, скопипастил код туда — все заработало 🙂 Чудеса просто…
А вот такой насущный вопрос:
Собираю схему электронного одометра. Надо будет хранить пробег включая сотни метров. Ясно, что возможность записи в EEPROM закончится очень быстро. Вопрос: 100,000 записей это для всей памяти либо для одной ячейки? Т.е. могу ли я записать в оду ячейку 100000 раз потом перейти к следующей и т.д. таким образом использовать EEPROM долгое время? Если нет, то какой выход в данной ситуации можно посоветовать?
Спасибо!
1 применить память типа FRAM от Ramtron у ней число циклов перезаписи такое, что скорей у твоей машины все молекулы сотрутся.
2 держать данные в памяти, а на епром сбрасывать раз в 10-15 минут.
И 100 000 это для каждой ячейки.
Почему фигня в еепром при включении питания пишется? бодлевел вроде поставил.
Работа с параметрами в EEPROM, как не износить память
Введение
Доброго времени суток. Прошлая моя статья про параметры в EEPROM была, мягко говоря, немного недопонята. Видимо, я как-то криво описал цель и задачу которая решалась. Постараюсь в этот раз исправиться, описать более подробно суть решаемой проблемы и в этот раз расширим границы задачи.
А именно поговорим о том, как хранить параметры, которые необходимо писать в EEPROM постоянно.
Особенность таких параметров заключается в том, что их нельзя писать просто так в одно и то же место EEPROM, вы просто израсходуете все циклы записи EEPROM. Например, если, необходимо писать время работы один раз в 1 минуту, то нетрудно посчитать, что с EEPROM в 1 000 000 циклов записей, вы загубите его меньше чем за 2 года. А что такое 2 года, если обычное измерительное устройство имеет время поверки 3 и даже 5 лет.
Кроме того, не все EEPROM имеют 1 000 000 циклов записей, многие дешевые EEPROM все еще производятся по старым технологиям с количеством записей 100 000. А если учесть, что 1 000 000 циклов указывается только при идеальных условиях, а скажем при высоких температурах это число может снизиться вдвое, то ваша EEPROM способно оказаться самым ненадежным элементом уже в первый год работы устройства.
Поэтому давайте попробуем решить эту проблему, и сделать так, чтобы обращение к параметрам было столь же простым как в прошлой статье, но при этом EEPROM хватало бы на 30 лет, ну или на 100 (чисто теоретически).
Итак, в прошлой статье, я с трудом показал, как сделать, так, чтобы с параметрами в EEPROM можно было работать интуитивно понятно, не задумываясь, где они лежат и как осуществляется доступ к ним
Для начала проясню, для чего вообще нужно обращаться по отдельности к каждому параметру, этот момент был упущен в прошлой статье. Спасибо товарищам @Andy_Big и @HiSER за замечания.
Если использовать способ, который предложил пользователь @HiSER- это будет означать, что для перезаписи одного параметра размером в 1 byte, я должен буду переписать всю EEPROM. А если алгоритм контроля целостности подразумевает хранение копии параметров, то для 200 параметров со средней длиной в 4 байта, мне нужно будет переписать 1600 байт EEPROM, а если параметров 500, то и все 4000.
Малопотребляющие устройства или устройства, питающиеся от от токовой петли 4-20мА должны потреблять, ну скажем 3 мА, и при этом они должны иметь еще достаточно энергии для питания модема полевого интерфейса, графического индикатора, да еще и BLE в придачу. Запись в EEPROM очень энергозатратная операция. В таких устройствах писать нужно мало и быстро, чтобы средний ток потребления был не высоким.
Очевидно, что необходимо, сделать так, чтобы микроконтроллер ел как можно меньше. Самый простой способ, это уменьшить частоту тактирования, скажем до 500 КГц, или 1 Мгц (Сразу оговорюсь, в надежных применениях использование режима низкого потребления запрещено, поэтому микроконтроллер все время должен работать на одной частоте). На такой частоте, простая передача 4000 байт по SPI займет около 70 мс, прибавим к этому задержку на сохранение данных в страницу (в среднем 7мс на страницу), обратное вычитывание, и вообще обработку запроса микроконтроллером и получим около 3 секунд, на то, чтобы записать один параметр.
Поэтому в таких устройствах лучше чтобы доступ к каждому параметру был отдельным, и обращение к ним должно быть индивидуальным. Их можно группировать в структуру по смыслу, или командам пользователя, но лучше, чтобы все они не занимали больше одной страницы, а их адреса были выравнены по границам страницы.
Как работать с EEPROM, чтобы не износить её
Те кто в курсе, можете пропустить этот раздел. Для остальных краткое, чисто мое дилетантское пояснение.
Как я уже сказал, число записей в EEPROM ограничено. Это число варьируется, и может быть 100 000, а может и 1 000 000. Так как же быть, если я хочу записать параметр 10 000 000 раз? И здесь мы должны понять, как внутри EEPROM устроен доступ к ячейкам памяти.
Итак, в общем случае вся EEPROM разделена на страницы. Страницы изолированы друг от друга. Страницы могут быть разного размера, для небольших EEPROM это, скажем, 16, 32 или 64 байта. Каждый раз когда вы записываете данные по какому-то адресу, EEPROM копирует все содержимое страницы, в которой находятся эти данные, во внутренний буфер. Затем меняет данные, которые вы передали в этом буфере и записывает весь буфер обратно. Т.е. по факту, если вы поменяли 1 байт в странице, вы переписываете всю страницу. Но из-за того, что страницы изолированы друг от друга остальные страницы не трогаются.
Таким образом, если вы записали 1 000 000 раз в одну страницу, вы можете перейти на другую страницу и записать туда еще 1 000 000 раз, потом в другую и так далее. Т.е. весь алгоритм сводится к тому, чтобы писать параметр не в одну страницу, а каждый раз сдвигаться в следующую страницу. Можно закольцевать эти действия и после 10 раз, снова писать в исходную страницу. Таким образом, вы просто отводите под параметр 10 страниц, вместо 1.
Анализ требований и дизайн
Все требования можно сформулировать следующим образом:
Пользователь должен задать параметры EEPROM и время обновления параметра
На этапе компиляции нужно посчитать количество необходимых страниц (записей), чтобы уложиться в необходимое время работы EEPROM. Для этого нужно знать:
Количество циклов перезаписи
Время обновления параметра
Время жизни устройства
Хотя конечно, можно было дать возможность пользователю самому задавать количество записей, но что-то я хочу, чтобы все считалось само на этапе компиляции.
Каждая наша переменная(параметр) должна иметь уникальный начальный адрес в EEPROM
Мы не хотим сами руками задавать адрес, он должен высчитываться на этапе компиляции
При каждой следующей записи, адрес параметра должен изменяться, так, чтобы данные не писались по одному и тому же адресу
Это также должно делаться автоматически, но уже в runtime, никаких дополнительных действий в пользовательском коде мы делать не хотим.
Мы не хотим постоянно лазить в EEPROM, когда пользователь хочет прочитать параметр
Обычно EEPROM подключается через I2C и SPI, передача данных по этим интерфейсам тоже отнимает время, поэтому лучше кэшировать параметры в ОЗУ, и возвращать сразу копию из кеша.
При инициализации мы должны найти самую последнюю запись, её считать и закешировать.
За целостность должен отвечать драйвер.
За алгоритм проверки целостности отвечает драйвер, если при чтении он обнаружил несоответствие он должен вернуть ошибку. В нашем случае, пусть в качестве алгоритма целостности будет простое хранение копии параметра. Сам драйвер описывать не буду, но приведу пример кода.
Ну кажется это все наши хотелки. Как и в прошлой статье давайте прикинем дизайн класса, который будет описывать такой параметр и удовлетворять нашим требованиям:
Посмотрим на то, как реализуются наши требования таким дизайном.
Пользователь должен задать параметры EEPROM и время обновления параметр
При каждой следующей записи, адрес параметра должен изменяться, так, чтобы данные не писались по одному и тому же адресу
Еще одной особенностью нашего противоизносного параметра является тот факт, что кроме самого значения, мы должны хранить еще и его индекс. Индекс нужен нам для двух вещей:
По нему мы будет рассчитывать следующий адрес записи
Для того, чтобы после выключения/включения датчика найти последнюю запись, считать её и проинициализировать значением по адресу этой записи кеширумое значение в ОЗУ.
Давайте посмотрим как реализован метод расчета текущего адреса записи:
Мы не хотим постоянно лазить в EEPROM, когда пользователь хочет прочитать параметр
Теперь самое интересное, чтобы проинициализировать копию в ОЗУ правильным значением, необходимо при запуске устройства считать все записи нашего параметра и найти запись с самым большим индексом. Наверняка есть еще разные методы хранения данных, например, связанный список, но использование индекса, показалось мне ну прямо очень простым.
В общем-то и все класс готов, полный код класса:
Результат
Собственно все, теперь мы можем регистрировать в списке любые параметры:
Что произойдет в этом примере, когда мы будем писать 10,11,12. 15 в наш параметр. Каждый раз при записи, адрес параметра будет смещаться на размер параметра + размер индекса + размер копии параметра и индекса. Как только количество записей превысит максимальное количество, параметр начнет писаться с начального адреса.
На картинке снизу как раз видно, что число 15 с индексом 5 записалось с начального адреса, а 10 теперь нет вообще.
В данном случае после сброса питания, при инициализации, будет найдена запись с индексом 5 и значением 15 и это значение и индекс будут записаны в кэшируемую копию нашего параметра.
Вот и все, надеюсь в этой статье цель получилось пояснить более детально, спасибо за то, что прочитали до конца.