Что такое eeprom arduino
Как хранить данные в Arduino
У плат семейства плат Arduino есть несколько видов памяти. Во-первых, это статическое ОЗУ (оперативное запоминающее устройство), которая используется для хранения переменных в процессе выполнения программы. Во-вторых, это флеш-память, в которой хранятся написанные вами скетчи. И в-третьих, это EEPROM, которую можно использовать для постоянного хранения информации. Первый тип памяти – энергозависимый, он теряет всю информацию после перезагрузки Arduino. Вторые два типа памяти хранят информацию пока она не будет перезаписана новой, даже после отключения питания. Последний тип памяти – EEPROM – позволяет записывать данные, хранить их и считывать при необходимости. Эту память мы и рассмотрим сейчас.
Инструкция по использованию EEPROM в Arduino
1 Описание памяти EEPROM
EEPROM означает Electrically Erasable Programmable Read-Only Memory, т.е. электрически стираемое перепрограммируемое постоянное запоминающее устройство. Данные в этой памяти могут храниться десятки лет после отключения питания. Количество циклов перезаписи – порядка нескольких миллионов раз.
2 Библиотека EEPROM
| Функция | Назначение |
|---|---|
| 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[address] | позволяет использовать идентификатор «EEPROM» как массив, чтобы записывать данные в память и считывать их из памяти. |
Чтобы задействовать библиотеку в скетче, подключаем её директивой #include EEPROM.h.
3 Запись целых чисел в EEPROM
Если число больше, чем 255, то с помощью операторов highByte() и lowByte() его нужно делить на байты и записывать каждый байт в свою ячейку. Максимальное число при этом – 65536 (или 2 16 ).
Смотрите, монитор последовательного порта в ячейку 0 просто выводит число, меньшее, чем 255. В ячейках 1 и 2 хранится большое число 789. При этом ячейка 1 хранит множитель переполнения 3, а ячейка 2 – недостающее число 21 (т.е. 789 = 3×256 + 21).
Запись целых чисел в EEPROM Arduino
Чтобы заново «собрать» большое число, разобранное на байты, есть функция word(): int val = word(hi, low), где «hi» и «low» – это значения старшего и младшего байтов числа «val».
Во всех остальных ячейках, которые не были нами ни разу записаны, хранятся числа 255.
4 Запись чисел с плавающей запятой и строк в EEPROM
Для записи чисел с плавающей запятой и строк нужно использовать метод EEPROM.put(), а для чтения – EEPROM.get().
В процедуре setup() сначала запишем число с плавающей запятой «f». Затем сдвинемся на количество ячеек памяти, которое занимает тип «float», и запишем строку символов «char» ёмкостью 20 ячеек.
В процедуре loop() будем считывать все ячейки памяти и пытаться расшифровать их сначала как тип «float», а затем как тип «char», и выводить результат в последовательный порт.
Запись чисел с плавающей запятой в EEPROM Arduino
Видно, что значение в ячейках с 0 по 3 правильно определилось как число с плавающей точкой, а начиная с 4-ой – как строка.
Появляющиеся значения ovf (переполнение) и nan (не число) говорят о том, что значение в ячейке памяти по этому адресу не может быть корректно преобразовано в число с плавающей точкой. Если вы точно знаете, какого типа данные какие ячейки памяти занимают, то у вас не будет возникать проблем.
5 Работа с EEPROM как с массивом
Очень удобная возможность – обращение к ячейкам памяти как к элементам массива EEPROM. В данном скетче в процедуре setup() мы сначала запишем данные в 4 первых байта, а в процедуре loop() ежеминутно будем считывать данные из всех ячеек и выводить их в последовательный порт.
Работа с ячейками памяти EEPROM Arduino как с элементами массива
Использование EEPROM на Arduino
От ROM к EEPROM
ROM (ПЗУ, Постоянное запоминающее устройство) расшифровывается как Read-Only Memory (только для чтения) и использовалась в ранних микроконтроллерах для обычного хранения операционной системы компьютера.
Фактически, то, что использовалось, было PROM (программируемая память только для чтения) и программировалась или «прожигалась» внешне в специальном программаторе с высоким напряжением. Однажды запрограммированная, она становится неизменной и нужно начинать всё с самого начала.
Емкость EEPROM
EEPROM значительно медленнее оперативной памяти и имеет ограничение по количеству записей (обычно 1 миллион). Но это не должно стать проблемой, так как существует 2 версии EEPROM.
Далее появилась флеш-память, способная хранить гораздо больше данных в том же объеме. В то время как EEPROM может записываться байт за байтом или побайтово, флеш-память записывается блоками или большими фрагментами, обычно по 512 байт за раз. Обратите внимание, что количество раз, которое вы можете записать, обычно составляет 100 000, так что вам придется с этим справляться.
Размер EEPROM-памяти может ввести в заблуждение, так как обычно она задается в битах, а не в байтах. 256K EEPROM может содержать 256K бит данных или всего 32K байт, около 16 страниц простого текста. Кроме того, она работает как энергонезависимая память, что означает, что она может сохранять свою память даже после повторного включения питания (в отличие от энергозависимой, которая теряет свое содержимое после выключения питания).
Что внутри чипа?
Зачем добавлять внешнюю EEPROM, а не просто использовать SD-карту? EEPROM намного быстрее для чтения и записи, чем SD-карта. Она имеет больше места (32 КБ по сравнению с 1 КБ в UNO) и более устойчива, чем SD-карта, которая может выпасть из держателя из-за вибрации.
Кроме того, протокол I2C упрощает использование по сравнению с SPI, используемым на SD-картах. 24LC256 поставляется в разных вариациях. Выше на рисунке показан пакет DIP IC, коммутационная плата, которая включает в себя подтягивающие резисторы, и еще один необычный со встроенными селекторами адресов.
Проект с использованием EEPROM
Дополнительную информацию о термисторах вы можете прочитать в Википедии.
Компоненты
Для создания нашего проекта мы будем использовать:
Схема соединения
Комплектующие соединяем согласно схеме ниже:
Настройка адреса
Если вы собираетесь подключить более одного 24LC256 EEPROM к микроконтроллеру, вам нужно будет изменить адреса каждого из них, сделав контакты с 1 по 3 высокими или низкими.
Поскольку имеется три (3) адресные линии, то может быть 8 устройств EEPROM (23 = 8). Но у каждого должен быть уникальный адрес. Если вы используете только один, заземлите все 3 контакта, и вы получите адрес 0x50.
Вывод Write-Protect, пин 7, обычно высокий (HIGH), но оставьте его низким (LOW).
Подключите соединение термистора и резистора 10 кОм к A0. Обратите внимание, что параметры уравнения Стейнхарта зависят от конкретного типа используемого термистора. Если у вас другой тип, результаты могут отличаться, но вы можете вычислить параметры на этой странице.
Скетч
Теперь, с помощью Arduino IDE вы можете загрузить в Ардуино Уно следующий код:
Таким образом, вы можете использовать функции для чтения/записи отдельных байтов или символов или через цикл или длинную строку.
Вывод в последовательном окне
Последовательное окно должно выглядеть как-то так:
На этом всё. Хороших и рабочих вам проектов.
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 памятью
Вот и добрались мы до третьего типа памяти, доступного на Arduino: EEPROM (англ. Electrically Erasable Programmable Read-Only Memory – электрически стираемое перепрограммируемое постоянное запоминающее устройство (ЭСППЗУ)), она же энергонезависимая память. Вспомним остальные типы памяти, Flash и SRAM, и их возможности по хранению данных:
| Тип | Чтение из программы | Запись из программы | Очистка при перезагрузке |
| Flash | Да, PROGMEM | Можно, но сложно | Нет |
| SRAM | Да | Да | Да |
| EEPROM | Да | Да | Нет |
Простыми словами: EEPROM – память, к которой мы имеем полный доступ из выполняющейся программы, т.е. можем во время выполнения читать и писать туда данные, и эти данные не сбрасываются при перезагрузке МК. Круто? Круто. Зачем?
Единственный важный момент: EEPROM имеет ресурс по количеству перезаписи ячеек. Производитель гарантирует 100 000 циклов записи каждой ячейки, по факту это количество зависит от конкретного чипа и температурных условий, независимые тесты показали 3-6 миллионов циклов перезаписи при комнатной температуре до появления первой ошибки, т.е. заявленные 100 000 взяты с очень большим запасом. Но есть небольшое уточнение – при заявленных 100 000 циклах перезаписи гарантируется сохранность записанных данных в течение 100 лет при температуре 24°C, если перезаписывать по миллиону – данные испортятся быстрее. В то же время количество чтений каждой ячейки неограниченно.
EEPROM представляет собой область памяти, состоящую из элементарных ячеек с размером в один байт (как SRAM). Объём EEPROM разный у разных моделей МК:
Основная задача при работе с EEPROM – не напутать с адресами, потому что каждый байт имеет свой адрес. Если вы пишете двухбайтные данные, то они займут два байта, и следующие данные нужно будет писать по адресу как минимум +2 к предыдущему, иначе они “перемешаются”. Рассмотрим пример хранения набора данных разного типа, расположенных в памяти последовательно друг за другом (в скобках я пишу размер текущего типа данных, на размер которого увеличится адрес для следующего “блока”):
Важный момент: все ячейки имеют значение по умолчанию (у нового чипа) 255.
Скорость работы с EEPROM (время не зависит от частоты системного клока):
Возможны искажения при записи данных в EEPROM при слишком низком VCC (напряжении питания), настоятельно рекомендуется использовать BOD или вручную мониторить напряжение перед записью.
При использовании внутреннего тактового генератора на 8 МГц, его отклонение не должно быть выше 10% (7.2-8.8 МГц), иначе запись в EEPROM или FLASH скорее всего будет производиться с ошибками. Соответственно все разгоны внутреннего клока недопустимы при записи EEPROM или FLASH.
Для работы с EEPROM в среде Arduino у нас есть целых две библиотеки, вторая является более удобной “оболочкой” для первой. Рассмотрим их обе, потому что в “чужом скетче” может встретиться всё что угодно, да и совместное использование этих двух библиотек делает работу с EEPROM невероятно удобной.
Библиотека avr/eeprom.h
Запись:
Обновление:
Макросы:
Рассмотрим простой пример, в котором происходит запись и чтение единичных типов данных в разные ячейки:
Точно так же можно хранить массивы:
В библиотеке avr/eeprom.h есть ещё один очень полезный инструмент – EEMEM, он позволяет сделать автоматическую адресацию данных путём создания указателей, значение которым присвоит компилятор. Рассмотрим пример, в котором запишем в EEPROM несколько переменных, структуру и массив, раздав им автоматически адреса. Важный момент! Адреса задаются снизу вверх по порядку объявления EEMEM, я подпишу их в примере:
EEMEM сам раздаёт адреса, основываясь на размере данных. Важный момент: данный подход не занимает дополнительного места в памяти, т.е. нумерация адресов вручную цифрами, без создания EEMEM “переменных”, не занимает меньше памяти! Давайте вернёмся к нашему первому примеру и перепишем его с EEMEM. При указании адреса через EEMEM нужно использовать оператор взятия адреса &
Ну и напоследок, запись и чтение блока через EEMEM. Адрес придётся преобразовать в (const void*) вручную:
Таким образом можно добавлять “данные” для хранения в EEPROM прямо по ходу разработки программы, не думая об адресах. Рекомендую добавлять новые данные над старыми, чтобы адресация не сбивалась (напомню, адресация идёт снизу вверх, начиная с нуля).
Библиотека EEPROM.h
Библиотека EEPROM.h идёт в комплекте с ядром Arduino и является стандартной библиотекой. По сути EEPROM.h – это удобная оболочка для avr/eeprom.h, чуть расширяющая её возможности и упрощающая использование. Важный момент: подключая в скетч EEPROM.h мы автоматически подключаем avr/eeprom.h и можем пользоваться её фишками, такими как EEMEM. Рассмотрим инструменты, которые нам предлагает библиотека:
В отличие от avr/eeprom.h у нас нет отдельных инструментов для работы с конкретными типами данных, отличными от byte, и сделать write/update/read для float/long/int мы не можем. Но зато у нас есть всеядный put/get, который очень удобно использовать! Также можем пользоваться тем, что нам даёт avr/eeprom.h, которая подключается автоматически с EEPROM.h. Рассмотрим пример с чтением/записью байтов:
Гораздо удобнее чем write_block и read_block, не правда ли? Put и get сами преобразовывают типы и сами считают размер блока данных, использовать их очень приятно. Они работают как с массивами, так и со структурами.
EEPROM.h + avr/eeprom.h
Ну и конечно же, можно использовать одновременно все преимущества обеих библиотек, например автоматическую адресацию EEMEM и put/get. Рассмотрим на предыдущем примере, вместо ручного задания адресов используем EEMEM, но величину придётся привести к целочисленному типу, сначала взяв от него адрес, т.е. (int)&адрес_еемем
С возможностями библиотек разобрались, перейдём к практике.
Реальный пример
Рассмотрим пример, в котором происходит следующее: две кнопки управляют яркостью светодиода, подключенного к ШИМ пину. Установленная яркость сохраняется в EEPROM, т.е. при перезапуске устройства будет включена яркость, установленная последний раз. Для опроса кнопок используется библиотека GyverButton. Для начала посмотрите на первоначальную программу, где установленная яркость не сохраняется. Программу можно чуть оптимизировать, но это не является целью данного урока.
Полезные трюки
Инициализация
Под инициализацией я имею в виду установку значений ячеек в EEPROM “по умолчанию” во время первого запуска устройства. В рассмотренном выше примере мы действовали в таком порядке:
При первом запуске кода (и при всех дальнейших, в которых в ячейку ничего нового не пишется) переменная получит значение, которое было в EEPROM по умолчанию. В большинстве случаев это значение не подойдёт устройству, например ячейка хранит номер режима, по задумке разработчика – от 0 до 5, а из EEPROM мы прочитаем 255. Непорядок! При первом запуске нужно инициализировать EEPROM так, чтобы устройство работало корректно, для этого нужно определить этот самый первый запуск. Можно сделать это вручную, прошив программу, которая забьёт EEPROM нужными данными. Далее прошить уже рабочую программу. При разработке программы это очень неудобно, ведь количество сохраняемых данных может меняться в процессе разработки, поэтому можно использовать следующий алгоритм:
Рассмотрим на всё том же примере со светодиодом и кнопками:
Сброс до “заводских”
Скорость
Как я писал выше, скорость работы с EEPROM составляет:
При большом желании можно использовать ячейку вместо переменной, т.е. выше мы с вами рассматривали пример, в котором EEPROM читался в переменную в программе, и дальнейшая работа происходила уже с ней. При сильной нехватке оперативной памяти можно читать значение напрямую из EEPROM, ведь это занимает ничтожно мало времени. А вот с записью всё гораздо хуже, там целых 3.3 мс. Например так:
Для изменения значения придётся прочитать ячейку, выполнить нужные операции, и снова в неё записать. Ещё один удобный хак: можно ввести макросы на чтение и запись определённых значений, например:
Получим удобные макросы, с которыми писать код будет чуть быстрее и удобнее, т.е. строка SET_MODE(3) запишет 3 в ячейку 0
Уменьшение износа
Важная тема: уменьшение износа ячеек частыми перезаписями. Ситуаций может быть много, интересных решений для них – тоже. Рассмотрим простейший пример – всё тот же код со светодиодом и кнопкой. Делать будем следующее: записывать новое значение будем только в том случае, если после последнего нажатия на кнопку прошло какое-то время. То есть нам понадобится таймер (воспользуемся таймером на millis), при нажатии на кнопку таймер будет сбрасываться, а при срабатывании таймера будем писать актуальное значение в EEPROM. Также понадобится флаг, который будет сигнализировать о записи и позволит записать именно один раз. Алгоритм такой:
Посмотрим на всё том же примере:
Вариантов уменьшения износа ячеек EEPROM можно придумать много, уникально под свою ситуацию. Есть даже библиотеки готовые, например EEPROMWearLevel. Есть очень интересная статья на Хабре, там рассмотрено ещё несколько хороших алгоритмов и даны ссылки на ещё большее их количество.