Виды eeprom. Как очистить EEPROM (Энергонезависимую память). Внутренняя энергонезависимая память EEPROM
Урок 15
Часть 1
Внутренняя энергонезависимая память EEPROM
Я думаю, может не все, но очень многие знают, что в контроллерах AVR помимо основной оперативной памяти, а также памяти для хранения прошивки существует ещё и энергонезависимая память типа EEPROM . Данная память сделана по технологии электрического стирания информации, что в отличие от её предшественника EPROM, в котором стирание производилось только при помощи ультрафиолетовых лучей, позволило использовать данный тип памяти практически повсеместно. Как мы знаем, ещё существует энергонезависимая память типа Flesh, которая стоит намного дешевле, но у которой также есть существенный минус. Там невозможно стереть отдельный байт, стирание производится только блоками, что не совсем удобно в некоторых случаях, особенно когда информации требуется хранить немного, и информация данная представляет собой небольшие настроечные параметры. Поэтому нам стоит также остановиться на данном типе памяти. И причем не только из-за того, что он присутствует в контроллере, а из-за того, что это очень удобно для хранения некоторых величин, которые нужны нам будут даже после того, как контроллер потерял питание.
Так как мы работаем с контроллером Atmega8A, техническую документацию данного МК мы и откроем и увидим там, что всего такой памяти у нас 512 байт. Это тем не менее не так мало. Если мы, например будем какой-нибудь будильник программировать, чтобы данные установки не потерялись после отключения питания, мы вполне можем с вами обратиться к данной памяти. Также в документации написано, что данная память гарантированно переживёт 100000 циклов записи/считывания.
Теперь напрашивается вопрос. Как же организован процесс работы с данной памятью в микроконтроллере AVR ? Как всегда, компания Atmel об этом позаботилась и организовала данный процесс на аппаратном уровне, что очень радует потому, что нам постоянно приходится беречь ресурсы контроллера. Для управления данным аппаратным уровнем существуют определенные регистры.
Один из них — регистровая пара EEAR . Почему пара, а потому что 512 адресов не влезут в 8 бит, требуется ещё один
Как именно мы будем адресоваться, мы увидим в процессе программирования EEPROM .
Следующий — регистр данных EADR
В данный регистр мы будем записывать данные для того чтобы записать их в определённый адрес памяти EEPROM, а также чтобы считать их из определённого адреса той же самой памяти.
Ну и как водится, практически ни одна периферия и технология, организованная на аппаратном уровне, не обходится без управляющего регистра. У нас управляющим регистром является регистр EECR
Давайте сразу немного познакомимся с битами данного регистра.
Бит EERE — бит, заставляющий начать процесс чтения из памяти EEPROM. И, как только данные считались и записались в регистр данных, этот бит сбросится. Поэтому мы можем считать даннй бит не только управляющим, но и статусным или битом состояния.
Бит EEWE — бит, установка которого даёт команду контроллеру записать данные из регистра данных в определенный адрес EEPROM. После завершения процедуры записи, данный бит также сбрасывается самостоятельно.
Бит EEMWE — бит, разрешающий (не начинающий) процесс записи.
Бит EERIE — бит, разрешающий прерывания.
Ну, теперь перейдём к проекту. Проект был создан обычным стандартным образом и назван Test13 . Также был подключен файл main.h и созданы файлы eeprom.h и eeprom.c .
Вот исходный код созданных файлов
Test13.c:
#include "main.h"
int main ( void )
{
while (1)
{
}
}
#ifndef MAIN_H_
#define MAIN_H_
#define F_CPU 8000000UL
#include
#include
#include
#include
#include
#include "eeprom.h"
#endif /* MAIN_H_ */
eeprom.h
#ifndef EEPROM_H_
#define EEPROM_H_
#include "main.h"
void EEPROM_write ( unsigned int uiAddress , unsigned char ucData );
unsigned char EEPROM_read ( unsigned int uiAddress );
#endif /* EEPROM_H_ */
eeprom.c
#include "eeprom.h"
Сначала, соответственно, мы попробуем записать данные в память EEPROM. Ну, оно и логично, так как пока мы ничего не записали, нам читать также нечего.
Ну, давайте не будем забивать голову и вставим код функции записи, также и функции чтения из примера в технической документации в файл eeprom.c и уберем англоязычные комментарии, вставив туда русскоязычные. После всех исправлений файл станет вот таким
#include "eeprom.h"
void EEPROM_write ( unsigned int uiAddress , unsigned char ucData )
{
while ( EECR & (1<< EEWE ))
{}
EEAR = uiAddress ; //Устанавливаем адрес
EEDR = ucData ; //Пищем данные в регистр
EECR |= (1<< EEMWE ); //Разрешаем запись
EECR |= (1<< EEWE ); //Пишем байт в память
}
unsigned char EEPROM_read ( unsigned int uiAddress )
{
while ( EECR & (1<< EEWE ))
{} //ждем освобождения флага окончания последней операцией с памятью
EEAR = uiAddress ; //Устанавливаем адрес
EECR |= (1<< EERE ); //Запускаем операцию считывания из памяти в регистр данных
return EEDR ; //Возвращаем результат
}
Напишем прототипы на данные функции в файле eeprom.h
#include "main.h"
void EEPROM_write ( unsigned int uiAddress , unsigned char ucData );
unsigned char EEPROM_read ( unsigned int uiAddress );
Теперь вызовем функцию записи в функции main() и тем самым попробуем записать какую-нибудь 8-битную величину по адресу 1. Вообще, адресация в данной памяти начинается с 0
int main ( void )
EEPROM_write (1, 120);
While (1)
Используем мы в качестве опытов ту же самую отладочную плату, вообще ничего к ней не подключая
Соберём проект и перейдём в программу для прошивки Avrdude .
Выберем там наш файл прошивки, затем попытаемся считать контроллер, затем всё сотрем по кнопке "стереть все"
Также в программе avrdude есть ещё одна строка "Eeprom". Данную строку мы можем использовать, чтобы записать в данную память не программно, а из файла. Но мы будем писать из нашей программы, а данную строку будем использовать, чтобы читать в файл память EEPROM. Можно написать в эту строку путь от руки и файл создастся сам. Напишем, например "C:\1\11111" и нажмем "Чтение", и по данному пути запишется в указанный файл вся информация из памяти EEPROM
Вы можете писать любой путь, лишь бы только указанный в нем слева носитель с такой буквой существовал и был доступен для записи. Также папку лучше создать тоже заранее.
Найдём теперь на диске данный файл и откроем его в блокноте
Данный файл имеет приблизительно такой же формат как и файл прошивки. Сначала адрес, затем 32 байта информационных и затем контрольная сумма на эти 32 байта. Если мы не разу не записывали ничего в память EEPROM, то по всем адресам у нас будут FF, то есть во всех битах памяти у нас единички.
Закрываем файл, пытаемся прошить контроллер, затем опять читаем память EEPROM в файл и откроем файл
Мы видим, что в файл записалось число "78", что и означает 120 в десятичном формате.
Теперь попробуем нажать кнопку "Стереть всё", в этом случае память EEPROM стетеься не должна.
Читаем опять EEPROM в файл, открываем файл и видим, что память стёрлась, у нас опять везде "FF".
Почему так произошло? Потому что нужно настроить фьюзы. Читаем фьюзы
Обратим внимание на бит EESAVE. Когда данный бит в единице (как у нас и есть, биты же с инверсией), то мы заставляем при отключении питания, а также при стирании стирать память EEPROM. А чтобы такого не происходило, данный бит нужно сбросить, то есть поставить в него галку и прошить фьюзы.
Прошиваем фьюзы, стираем контроллер, прошиваем контроллер, опять стираем, читаем память EEPROM в файл и открываем его. Теперь мы видим, что ничего у нас не стёрлось
Теперь попробуем отключить контроллер от питания и подать через некоторое время питание опять. Опять читаем EEPROM в файл, у нас всё цело. Отлично!
В следующей части урока мы попробуем программно прочитать данные из памяти EEPROM.
Смотреть ВИДЕОУРОК (нажмите на картинку)
Post Views: 7 259
Обнуление памяти 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. Описание различных датчиков и модулей. Советы и наставления начинающим. Пишите и размещайте свои статьи в
Электрически стираемые программируемые микросхемы постоянной памяти (EEPROM) являются металлическими оксидными полупроводниковыми компьютерными микросхемами, которые используются на печатной плате. Этот тип чипа можно стереть и перепрограммировать с использованием сильного электронного сигнала. Поскольку это можно сделать, не удаляя чип с устройства, к которому он подключен, чипы EEPROM используются во многих отраслях.
Микросхема EEPROM содержит энергонезависимую память, поэтому её данные не теряются при нарушении питания чипа. Микросхема такого типа может быть запрограммирована выборочно, что означает, что часть её памяти может быть изменена с помощью новой перезаписи, не затрагивая остальную память. Информация, хранящаяся внутри микросхемы EEPROM, является постоянной, пока она не будет стёрта или перепрограммирована, что делает её ценным компонентом в компьютерах и других электронных устройствах.
Микросхемы EEPROM созданы на основе транзисторов с плавающим затвором. Микросхема EEPROM запрограммирована путём принудительной программируемой информации в виде электронов через оксид затвора. Затем плавающий затвор обеспечивает хранение этих электронов. Ячейка памяти считается запрограммированной, когда она заряжается электронами, и это представляется нулём. Если ячейка памяти не заряжена, она не запрограммирована, и она представлена единицей.
Для широкого спектра устройств требуется память, поэтому чипы EEPROM имеют множество применений в области бытовой электроники. Они используются в игровых системах, телевизорах и компьютерных мониторах. Слуховые аппараты, цифровые камеры, технология Bluetooth и игровые системы также используют чипы EEPROM. Они используются в телекоммуникационной, медицинской и обрабатывающей промышленности. Персональные и бизнес-компьютеры содержат ЭСППЗУ.
Чип EEPROM также имеет широкий спектр применений в автомобильной отрасли. Он используется в антиблокировочных системах, подушках безопасности, электронных средствах контроля устойчивости, трансмиссиях и блоках управления двигателем. Чипы EEPROM также используются в кондиционерах, дисплеях приборной панели, модулях управления корпусом и системах ввода без ключа. Эти чипы помогают контролировать расход топлива, а также используются в различных диагностических системах.
Существует ограничение на количество повторений, которое может быть перезаписано чипом EEPROM. Слой внутри чипа постепенно повреждается многочисленными переписываниями. Это не большая проблема, потому что некоторые чипы EEPROM могут быть изменены до миллиона раз. Дальнейшие успехи в области технологий, скорее всего, окажут положительное влияние на то, на что могут рассчитывать микросхемы памяти в будущем.
Микросхемы разного назначения применяются в составе электроники современной техники. Огромное многообразие такого рода компонентов дополняют микросхемы памяти. Этот вид радиодеталей (среди электронщиков и в народе) зачастую называют просто – чипы. Основное назначение чипов памяти – хранение определённой информации с возможностью внесения (записи), изменения (перезаписи) или полного удаления (стирания) программными средствами. Всеобщий интерес к чипам памяти понятен. Мастерам, знающим как программировать микросхемы памяти, открываются широкие просторы в области ремонта и настройки современных электронных устройств.
Микросхема памяти — это электронный компонент, внутренняя структура которого способна сохранять (запоминать) внесённые программы, какие-либо данные или одновременно то и другое.
По сути, загруженные в чип сведения представляют собой серию команд, состоящих из набора вычислительных единиц микропроцессора.
Следует отметить: чипы памяти всегда являются неотъемлемым дополнением микропроцессоров – управляющих микросхем. В свою очередь микропроцессор является основой электроники любой современной техники.
Набор электронных компонентов на плате современного электронного устройства. Где-то среди этой массы радиодеталей приютился компонент, способный запоминать информацию
Таким образом, микропроцессор управляет , а чип памяти хранит сведения, необходимые микропроцессору.
Программы или данные хранятся в чипе памяти как ряд чисел — нулей и единиц (биты). Один бит может быть представлен логическими нулем (0) либо единицей (1).
В единичном виде обработка битов видится сложной. Поэтому биты объединяются в группы. Шестнадцать бит составляют группу «слов», восемь бит составляют байт — «часть слова», четыре бита — «кусочек слова».
Программным термином для чипов, что используется чаще других, является байт. Это набор из восьми бит, который может принимать от 2 до 8 числовых вариаций, что в общей сложности даёт 256 различных значений.
Для представления байта используется шестнадцатеричная система счисления, где предусматривается использование 16 значений из двух групп:
- Цифровых (от 0 до 9).
- Символьных (от А до F).
Поэтому в комбинациях двух знаков шестнадцатеричной системы также укладываются 256 значений (от 00h до FFh). Конечный символ «h» указывает на принадлежность к шестнадцатеричным числам.
Организация микросхем (чипов) памяти
Для 8-битных чипов памяти (наиболее распространенный тип) биты объединяются в байты (8 бит) и сохраняются под определённым «адресом».
По назначенному адресу открывается доступ к байтам. Вывод восьми битов адреса доступа осуществляется через восемь портов данных.
Организация структуры запоминающего устройства. На первый взгляд сложный и непонятный алгоритм. Но при желании разобраться, понимание приходит быстро
Наш контроллер печи почти готов – однако пока он остаётся контроллером-«золотой рыбкой», который помнит все настройки только пять минут до первого выключения питания. Чтобы запомнить наши настройки, значение заданной температуры и точки калибровки даже после отключения питания, нужно использовать энергонезависимую память – 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-файл отдельно; затем убираем инициализацию при создании переменных.
Вот и все – наша печка готова!