Что такое инициализация памяти

Электроника для всех

Блог о электронике

AVR. Учебный курс. Стартовая инициализация

Инициализация памяти
Мало кто подозревает о том, что при включении в оперативке далеко не всегда все байты равны 0xFF. Они могут, но не обязаны. Равно как и регистры РОН не всегда равны нулю при запуске. Обычно да, все обнулено, но я несколько раз сталкивался со случаями когда после перезапуска и/или включения-выключения питания, микроконтроллер начинал творить не пойми что. Особнно часто возникает когда питание выключаешь, а потом, спустя некоторое время, пара минут, не больше, включаешь. А всему виной остаточные значения в регистрах.

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

RAM_Flush: LDI ZL,Low(SRAM_START) ; Адрес начала ОЗУ в индекс LDI ZH,High(SRAM_START) CLR R16 ; Очищаем R16 Flush: ST Z+,R16 ; Сохраняем 0 в ячейку памяти CPI ZH,High(RAMEND+1) ; Достигли конца оперативки? BRNE Flush ; Нет? Крутимся дальше! CPI ZL,Low(RAMEND+1) ; А младший байт достиг конца? BRNE Flush CLR ZL ; Очищаем индекс CLR ZH

Поскольку адрес оперативки у нас двубайтный, то мы вначале смотрим, чтобы старший байт совпал с концом, а потом добиваем оставшиеся 255 байт в младшем байте адреса.
Далее убиваем все регистры от первого до последнего. Все, контроллер готов к работе.

LDI ZL, 30 ; Адрес самого старшего регистра CLR ZH ; А тут у нас будет ноль DEC ZL ; Уменьшая адрес ST Z, ZH ; Записываем в регистр 0 BRNE PC-2 ; Пока не перебрали все не успокоились

За процедурку зануления регистров спасибо Testicq

Либо значения сразу же инициализируются нужными величинами. Но, обычно, я от нуля всегда пляшу. Поэтому зануляю все.

Спасибо. Вы потрясающие! Всего за месяц мы собрали нужную сумму в 500000 на хоккейную коробку для детского дома Аистенок. Из которых 125000+ было от вас, читателей EasyElectronics. Были даже переводы на 25000+ и просто поток платежей на 251 рубль. Это невероятно круто. Сейчас идет заключение договора и подготовка к строительству!

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

58 thoughts on “AVR. Учебный курс. Стартовая инициализация”

я ещё помню, когда смотрел по линку на программатор на сайт Николаева, то тоже видел там раздел про «тонкости». про использование символических имён, работу с флагами и компаратор в режиме пониженно потребления ) мелочи, а знать надо

Такой метод инициализации катит только если у тебя переменные инициируются нулями. Но такое не всгеда бывает.

Как вариант, хранить во флеше слепок начальных значений переменных и копировать их. Или просто не забывать инициировать их по мере надобности.

А чистить регистры и место для стека считаю пустой тратой тактов =) Регистры ты так или иначе будешь инициировать по ходу дела, а стек у тебя изначально нулевой и при росте перекроет любые левые значения.

Ну так а что мешает потом забить переменные нужынми значениями. Все проще чем слепок памяти держать.

По поводу регистров. Да вот вчера трахался с тем, что у меня на Tiny2323 после вырубания питания значение в регистре торчало по несколько минут. Врубаю МК — на тебе — мигать начинать самопроизвольно. Мигание у меня зависило от состояния регистра R20.

Сам подход, что ты полагаешь, что у тебя в регистрах есть значения по умолчанию — порочен. Сейчас ты чистишь всё что можно после сброса и это работает. Но когда тебе потребуется в ходе работы переинициализировать какой-то модуль, ты опять столкнёшься с тем, что в регистрах у тебя мусор. Каждый модуль должен сам инициализировать то что ему нужно.
Я у себя для каждого модуля пишу процедуру void xxxInit(void), которая полностью готовит модуль к работе. И это при том, что ‘C’ умеет инициировать переменные при старте.

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

Знаю. Я тоже пишу на асме. Но это тебя не освобождает от инициализации переменных =)

Тут фишка такая, когда ты используешь умолчальные инициализации, ты тереяшь в понятности кода.

Сделай инициализацию явно, и уже потом, на этапе оптимизации сможешь эту строчку закомментить с комментарием «// а оно и так уже такое». В дальнейшем избавишь себя от головной боли.

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

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

потом все глобальные переменные определить — как надо. все те, что в функциях — смотреть внимательно.

я конечно понимаю, что тут не бывает — когда в массив 1000 на 1000 забивают мемкопи инициализирующий )

вообщем, инициализация тоже имеет в себе тонкости.

В микроконтроллерах при сбросе или холодном старте обычно задается наиболее безопасная конфигурация периферии в спецрегистрах, регистры же общего назначения и оперативка никогда не очищаются, по крайней мере в массовых типах микроконтроллеров. (Среди тех PIC, ATMEL и INTEL, про которые читал или использовал сам, таких не попадалось). Так что «Спасение утопающих — дело рук самих утопающих». Просто должно войти в привычку не пускать ничего на самотек, все определять заранее. Сразу отпадет куча проблем, а высвободившееся при отладке время можно будет направить на повышение «интелекта» самой программы.

А разьве прерывание таймера не выполнится после выхода из прерывания INT0?

Выполнится, но мне надо было прерывание таймера внутри обработчика INT0

Слабо представляю зачем это нужно. Сколько по времени у тебя выполнялся обработчик INT0?

На обработчик INT0 у меня повешен альтернативный режим работы девайса. Так что он перехватывает на себя управление и держит его до тех пор пока не отработает всю логику.

Вот тут как раз бы и пригодились многоуровневые приоритетные прерывания. Хорошая была штука! При работе в реальном времени с информацией, которую специально для контроллера никто повторять не будет, они многое очень сильно упрощали. Например, в одной из разработок, контролировавшей процент искажений одновременно в 4 телеграфных каналах, в диалоговом режиме, с одновременным накоплением и выдачей результатов, и обслуживанием еще управляющего канала — аппарата «диспетчера», чтобы уложиться в требуемую точность в +-1%, требовалось для худшего случая (если во время обработки прерывания от одного канала поступали прерывания от всех остальных 4), уложиться до 200мксек. Мне удалось обрабатывать самые худшие случаи максимум за 160! (на 580 процессоре с контроллером прерываний 580ВН59). Правда, пришлось поддержать аппаратно простенькой схемкой (на 555ЛП5), сравнивавшей текущее состояние с предыдущим, которое обработчик прерывания обновлял в специальном регистре, и также формировавшей запрос прерывания при каждом изменении полярности в любом из каналов. Мерялось смещение каждого перехoда в каждом знаке, с определением максимального отдельно по + и по — для каждого из каналов, с пересчетом в проценты. Тот контроллер до сих пор в работе, правда, прошивку в 573РФ5 пришлось один раз обновить (заряд стек). Сделал я его году в 86, а программа была около 3600 байт. Всего на плате могло быть установлено до 8кб(4шт РФ5 по 2к). ОЗУ было 4 кб.

Источник

Объясните, что такое инициализация?

Пример из компьютеров: если стирается флеш-БИОС, машина умирает.
Чтобы такого не происходило (а особенно это неприятно, если микросхема на пайке, а не на кровати), сейчас делают нестираемую часть прошивки, в которой записана процедура восстановления БИОС с внешнего носителя (например, у Асусов сделано так).

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

Память с прожигаемыми перемычками существует в основном в виде программируемых логических матриц (ПЛМ), сложных дешифраторов.

Память с УФ стиранием программируется нулями, а единицы записываются сразу во все ячейки, при освещении УФ лампой.

В EEPROM и нули, и единицы записываются электрически.

Все начинают вспоминать про микросхемы мол это микропроцессор, а на транзисторах или лампах это процессоры.

На самом деле дело в программах. Если процессор «заточен» выполнять микропрограммы, то это микропроцессор. А структурно процессор и микропроцессор одинаковы и технологически тоже.JulyP

Все начинают вспоминать про микросхемы мол это микропроцессор, а на транзисторах или лампах это процессоры.

На самом деле дело в программах. Если процессор «заточен» выполнять микропрограммы, то это микропроцессор. А структурно процессор и микропроцессор одинаковы и технологически тоже.

Странное утверждение.
Особенно про технологию.

Если структурно одинаковы, то почему микропрограмма только у микропроцессора?
Были микропроцессоры и с внешним микрокодом.

Впрочем, сам спор довольно схоластичен.

Очень часто программы инициализации хранятся во внутренних программах микроконтроллера и имеют конкретную версию. А во внешней памяти хранится программа и данные на конкретный телик.

Исходя из вышеописанного нельзя называть перепрошивку внешней памяти инициализацией. Может просто называть перепрошивкой?Caша

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

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

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

Источник

Вся правда об ОСРВ. Статья #30. Инициализация и процедуры запуска Nucleus SE

У любой операционной системы есть определенный механизм запуска. Принцип работы этого механизма у каждой системы свой. Обычно говорят, что система загружается (англ. boot), это сокращение от «bootstrap», которое отсылает к выражению «pull oneself over a fence by one’s bootstraps» (перебраться через ограду, потянув себя за ремешки на обуви), что примерно описывает, как система самостоятельно переходит из состояния, в котором память заполнена пустотой (прим. переводчика: если совсем точно, то мусором) к стабильному выполнению программ. Традиционно в память загружается небольшая часть программы, она может храниться в ПЗУ. В прошлом она могла вводиться при помощи переключателей на передней панели компьютера. Этот начальный загрузчик считывал более сложную программу загрузки, которая уже загружала операционную систему. Сегодня настольный компьютер загружается следующим образом: код в BIOS ищет устройства (жесткие диски, CD-ROM, USB-флешки), с которых можно загрузиться, после чего загружается операционная система.

ОС для встраиваемых систем также может инициализироваться подобным образом. И в самом деле, встраиваемые операционные системы, разработанные на основе настольных операционных систем, так и загружаются. Но в большинстве «классических» ОСРВ используется гораздо более простой (а, следовательно, более быстрый) способ.

Операционная система – часть программного обеспечения. Если это программное обеспечение уже находится в памяти (например, в том или ином виде ПЗУ), то требуется всего лишь сделать так, чтобы последовательность команд ЦП после сброса заканчивалась выполнением кода инициализации ОС. Именно так работают большинство ОСРВ, в том числе и Nucleus SE (примечание переводчика: и к нашей ОСРВ МАКС это тоже относится).

Большинство средств разработки встраиваемого программного обеспечения включают в себя необходимый код запуска для обработки сброса ЦП и передачи управления во входную точку (Entry Point) в функции main(). Распространяемый код Nucleus SE не имеет дела с этим процессом, так как он должен быть максимально портируемым. Вместо этого, он содержит функцию main(), которая берет контроль над ЦП и инициализирует и запускает ОС. Эта функция будет подробно рассмотрена ниже.

Инициализация памяти

Объявления всех статических переменных в коде Nucleus SE начинаются с префикса ROM или RAM, чтобы показать, где их следует размещать. Эти две директивы #define определены в файле nuse_types.h и должны быть сконфигурированы с учетом особенностей используемого набора инструментов для разработки (компилятор и компоновщик). Обычно ROM должен иметь тип const (прим. переводчика: из моего опыта, const – не всегда достаточно, лучше – static const), а RAM – пустое значение.

Все переменные ROM инициализируются статически, что логично. Переменные RAM не инициализируются статически (так как это работает только с определенными наборами инструментов, которые настроены на автоматическое копирование из ПЗУ в ОЗУ); явный код инициализации включен в приложение и будет подробно описан ниже.

Nucleus SE не хранит «константных» данных в ОЗУ, которая обычно в дефиците у небольших систем. Вместо использования сложных структур данных для описания объектов ядра используются наборы таблиц (массивов), которые без проблем размещаются в ПЗУ или ОЗУ, в зависимости от необходимости.

Функция main()

Ниже приведен полный код функции main() Nucleus SE:

Последовательность операций довольно проста:

Функция NUSE_Init()

Эта функция инициализирует все переменные ядра и структуры данных Nucleus SE.

Инициализация задач

Если планировщик Run to Completion не был сконфигурирован, инициализируется контекстный блок для задачи NUSE_Task_Context[task][]. Большинству элементов не присваиваются значения, так как они представляют общие машинные регистры, которые должны иметь промежуточное значение при запуске задачи. В примере (Freescale ColdFire) реализации Nucleus SE (но и у других процессоров механизм будет аналогичным) последние три записи заданы явным образом:

Если активирована приостановка задачи (т.е. служебный вызов API NUSE_Task_Sleep()), счетчику таймаута задачи (NUSE_Task_Timeout_Counter[task]) присваивается нулевое значение.

Если активировано состояние ожидания задачи (task suspend), статус задачи (NUSE_Task_Status[task]) инициализируется. Это начальное значение задается пользователем (в NUSE_Task_Initial_State[task]), если активирована поддержка начального состояния задачи. В противном случае состоянию присваивается NUSE_READY.

Если активирован счетчик планировок, счетчику задачи (NUSE_Task_Schedule_Count[task]) присваивается нулевое значение.

Инициализация пулов разделов

Ниже приведен полный код функции NUSE_Init_Partition_Pool():

«Использованному» счетчику пула разделов (NUSE_Partition_Pool__Partition_Used[pool]) присваивается нулевое значение.

Если активирована блокировка задач, счетчику заблокированных задач пулов разделов (NUSE_Partition_Pool_Blocking_Count[pool]) присваивается нулевое значение.

Инициализация почтовых ящиков

Ниже приведен полный код NUSE_Init_Mailbox():

Хранилищу данных почтовых ящиков (NUSE_Mailbox_Data[mailbox]) присваивается нулевое значение, и состояние (NUSE_Mailbox_Status[mailbox]) становится «неиспользуемым» (т.е. нулевым).

Если активирована блокировка задач, счетчику заблокированных задач почтовых ящиков (NUSE_Mailbox_Blocking_Count[mailbox]) присваивается нулевое значение.

Инициализация очередей

Ниже приведен полный код функции NUSE_Init_Queue():

Указателям на начало и конец очереди (на самом деле, это индексы NUSE_Queue_Head[queue] и NUSE_Queue_Tail[queue]) присваиваются значения, указывающие на начало области данных очередей (т.е. они принимают нулевое значение). Счетчику элементов в очереди (NUSE_Queue_Items[queue]) также присваивается нулевое значение.

Если активирована блокировка задач, счетчику заблокированных задач очередей (NUSE_Queue_Blocking_Count[queue]) присваивается нулевое значение.

Инициализация каналов

Ниже приведен полный код функции NUSE_Init_Pipe():

Указателям на начало и конец канала (на самом деле, это индексы – NUSE_Pipe_Head[pipe] и NUSE_Pipe_Tail[pipe]) присваивается значение, указывающее на начало области данных канала (т.е. они принимают нулевое значение). Счетчику элементов в канале (NUSE_Pipe_Items[pipe]) также присваивается нулевое значение.

Если активирована блокировка задач, счетчику заблокированных задач канала (NUSE_Pipe_Blocking_Count[pipe]) присваивается нулевое значение.

Инициализация семафоров

Ниже приведен полный код функции NUSE_Init_Semaphore():

Счетчик семафоров (NUSE_Semaphore_Counter[semaphore]) инициализируется значением, заданным пользователем (NUSE_Semaphore_Initial_Value[semaphore]).

Если активирована блокировка задач, счетчику заблокированных задач семафора (NUSE_Semaphore_Blocking_Count[semaphore]) присваивается нулевое значение.

Инициализация групп событий

Ниже приведен полный код функции NUSE_Init_Event_Group():

Флаги группы событий сбрасываются, т.е. NUSE_Event_Group_Data[group] присваивается нулевое значение.

Если активирована блокировка задач, счетчику заблокированных задач группы флагов событий (NUSE_Event_Group_Blocking_Count[group]) присваивается нулевое значение.

Инициализация таймеров

Ниже приведен полный код NUSE_Init_Timer();

Состояние таймера (NUSE_Timer_Status[timer]) устанавливается в значение «неиспользуемое», т.е. FALSE.

Значение обратного отсчета (NUSE_Timer_Value[timer]) инициализируется значением, заданным пользователем (NUSE_Timer_Initial_Time[timer]).

Счетчику завершений (NUSE_Timer_Expirations_Counter[timer]) присваивается нулевое значение.

Инициализация кода приложения

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

У вызовов API есть ограничение: все действия, которые обычно приводят к активации планировщика, запрещены (например, приостановка/блокировка задач). Глобальной переменной NUSE_Task_State было присвоено значение NUSE_STARTUP_CONTEXT, чтобы отметить это ограничение.

Запуск планировщика

После того, как инициализация была завершена, остается только запустить планировщик, чтобы приступить к выполнению кода приложения – задач. Конфигурация планировщика и работа различных видов планировщиков была подробно описана в одной из предыдущих статей (#9), так что здесь потребуется лишь краткий итог.
Последовательность ключевых шагов следующая:

В следующей статье будет рассматриваться диагностика и проверка ошибок.

Источник

Работа с EEPROM памятью

Вот и добрались мы до третьего типа памяти, доступного на Arduino: EEPROM (англ. Electrically Erasable Programmable Read-Only Memory – электрически стираемое перепрограммируемое постоянное запоминающее устройство (ЭСППЗУ)), она же энергонезависимая память. Вспомним остальные типы памяти, Flash и SRAM, и их возможности по хранению данных:

Простыми словами: 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. Есть очень интересная статья на Хабре, там рассмотрено ещё несколько хороших алгоритмов и даны ссылки на ещё большее их количество.

Видео

Источник