Подключение I2C EEPROM к Arduino. Микроконтроллеры STM32: работа с внешним EEPROM
EEPROM — это энергонезавимая память с электрическим стиранием информации. Количество циклов записи-стирания в этих микросхемах достигает 1000000 раз. Заминающие ячейки в них, также как и в постоянных запоминающих устройствах с электрическим стиранием EPROM, реализуются на основе транзисторов с плавающим затвором. Внутреннее устройство этой запоминающей ячейки приведено на рисунке 1:
Рисунок 1. Запоминающая ячейка ПЗУ с электрическим стиранием (EEPROM)
Ячейка EEPROM памяти представляет собой МОП транзистор, в котором затвор выполняется из поликристаллического кремния. Затем в процессе изготовления микросхемы этот затвор окисляется и в результате он будет окружен оксидом кремния — диэлектриком с прекрасными изолирующими свойствами. В транзисторе с плавающим затвором при полностью стертом ПЗУ, заряда в "плавающем" затворе нет, и поэтому данный транзистор ток не проводит. При программировании, на второй затвор, находящийся над "плавающим" затвором, подаётся высокое напряжение и в него за счет туннельного эффекта индуцируются заряды. После снятия программирующего напряжения индуцированный заряд остаётся на плавающем затворе, и, следовательно, транзистор остаётся в проводящем состоянии. Заряд на его плавающем затворе может храниться десятки лет.
Подобная ячейка памяти применялась в ПЗУ с ультрафиолетовым стиранием (EPROM). В ячейке памяти с электрическим стиранием возможна не только запись, но и стирание информации. Стирание информации производится подачей на программирующий затвор напряжения, противоположного напряжению записи. В отличие от ПЗУ с ультрафиолетовым стиранием, время стирания информации в EEPROM памяти составляет около 10 мс.
Структурная схема энергонезависимой памяти с электрическим стиранием не отличается от структурной схемы масочного ПЗУ. Единственное отличие — вместо плавкой перемычки используется описанная выше ячейка. Ее упрощенная структурная схема приведена на рисунке 2.
Рисунок 2. Упрощенная структурная схема EEPROM
В качестве примера микросхем EEPROM памяти можно назвать отечественные микросхемы 573РР3, 558РР3 и зарубежные микросхемы серий AT28с010, AT28с040 фирмы Atmel, HN58V1001 фирмы Hitachi Semiconductor, X28C010 фирмы Intersil Corporation. В EEPROM памяти чаще всего хранятся пользовательские данные в сотовых аппаратах, которые не должны стираться при выключении питания (например адресные книги), конфигурационная информация роутеров или сотовых аппаратов, реже эти микросхемы применяются в качестве конфигурационной памяти FPGA или хранения данных DSP. EEPROM изображаются на принципиальных схемах как показано на рисунке 3.
Рисунок 3. Условно-графическое обозначение электрически стираемого постоянного запоминающего устройства
Чтение информации из параллельной EEPROM памяти производится аналогично чтению из масочного ПЗУ. Сначала на шине адреса выставляется адрес считываемой ячейки памяти в двоичном коде A0...A9, затем подается сигнал чтения RD. Сигнал выбора кристалла CS обычно используется в качестве дополнительного адресного провода для обращения к микросхеме. Временные диаграммы сигналов на входах и выходах этого вида ПЗУ приведены на рисунке 4.
Рисунок 4. Временные диаграммы сигналов чтения информации из EEPROM памяти
На рисунке 5 приведен чертеж типового корпуса микросхемы параллельной EEPROM памяти.
Рисунок 5. Чертеж корпуса микросхемы параллельной EEPROM
Обычно данные, которые хранятся в EEPROM требуются достаточно редко. Время считывания при этом не критично. Поэтому в ряде случаев адрес и данные передаются в микросхему и обратно через последовательный порт. Это позволяет уменьшить габариты микросхем за счет уменьшения количества внешних выводов. При этом используются два вида последовательных портов — SPI порт и I2C порт (микросхемы 25сXX и 24cXX серий соответственно). Зарубежной серии 24cXX соответствует отечественная серия микросхем 558РРX.
Внутренняя схема микросхем серии 24сXX (например AT24C01) приведена на рисунке 6.
Рисунок 6. Внутренняя схема микросхемы AT24C01
Подобные микросхемы широко используются для сохранения настроек телевизоров, в качестве памяти plug and play в компьютерах и ноутбуках, конфигурационной памяти ПЛИС и сигнальных процессоров (DSP). Применение последовательной EEPROM памяти позволило значительно уменьшить стоимость данных устройств и увеличить удобство работы с ними. Пример расположения данной микросхемы на печатной плате карты памяти компьютера приведен на рисунке 7.
Рисунок 7. EEPROM на печатной плате карты памяти компьютера
На рисунке 8 приведена схема электронной карты с применением внешней EEPROM микросхемы.
Рисунок 8. Схема электронной карты с применением внешней EEPROM
На данной схеме микроконтроллер PIC16F84 осуществляет обмен данными с EEPROM памятью 24LC16B. В таких устройствах, как SIM-карта, уже не применяется внешняя микросхема памяти. В SIM-картах сотовых аппаратов используется внутренняя EEPROM память однокристального микроконтроллера. Это позволяет максимально снизить цену данного устройства.
Схема управления для электрически стираемых программируемых ПЗУ получилась сложная, поэтому наметилось два направления развития этих микросхем:
- ЕСППЗУ (EEPROM) - электрически стираемое программируемое постоянное запоминающее устройство
- FLASH-ПЗУ
FLASH - ПЗУ отличаются от ЭСППЗУ тем, что стирание производится не каждой ячейки отдельно, а всей микросхемы в целом или блока запоминающей матрицы этой микросхемы, как это делалось в РПЗУ.
Рисунок 9. Условно-графическое обозначение FLASH памяти
При обращении к постоянному запоминающему устройству сначала необходимо выставить адрес ячейки памяти на шине адреса, а затем произвести операцию чтения из микросхемы. Эта временная диаграмма приведена на рисунке 11.
Рисунок 10. Временные диаграммы сигналов чтения информации из ПЗУ
На рисунке 10 стрелочками показана последовательность, в которой должны формироваться управляющие сигналы. На этом рисунке RD - это сигнал чтения, A - сигналы выбора адреса ячейки (так как отдельные биты в шине адреса могут принимать разные значения, то показаны пути перехода как в единичное, так и в нулевое состояние), D - выходная информация, считанная из выбранной ячейки ПЗУ.
Литература:
Вместе со статьей "Постоянные запоминающие устройства (ПЗУ)" читают:
Когда нужно длительное время хранить какие-нибудь рабочие данные, не боясь их потерять, используют штатную, встроенную в микроконтроллер, EEPROM память. Обычно размер этой памяти не велик и его хватает только для хранения каких-то небольших по объему данных, например пользовательских настроек или т.п. А если нужно хранить данные размером десяток килобайт, то понятно что встроенной памятью не обойтись и нужно подключать внешнее устройство хранения. И тут как нельзя лучше подходят внешние микросхемы EEPROM. Например микросхемы из серии 24LCxx от компании Microchip. Эти микросхемы поддерживают подключение по протоколу I2C и умеют хранить от 512 байт до 128 килобайт данных. К тому же, старшие модели могут работать в связке из себе подобных, таким образом размер памяти может быть увеличен за счет присвоения микросхемам памяти индивидуального адреса на I2C шине. В младших же моделях, все микросхемы имеют фиксированный адрес 1010.
В номенклатуре Microchip серии 24LC числовое значение после буквенного индекса обозначает объем памяти в килобитах
. Так, подопытная микросхема 24LC08 имеет на борту 8 килобит пространства под хранение данных (или 1 килобайт).
Подключение микросхемы
Данная микросхема выпускается в различных корпусах: DIP, SOIC, TSOP, DFN. Для каждого восьминогового типа корпуса сохраняется распиновка контактов.
Такое же расположение контактов имеют микросхемы старших моделей, поэтому они запросто могут быть заменены в случае нехватки ресурсов, без изменения типологии платы.
Назначение выводов микросхемы смотрим ниже:
A0, A1, A2 - в данной микросхеме не используются, в старших моделях они служат для присвоения микросхеме индивидуального адреса на I2C шине.
SDA – линия данных
SCL – линия тактовых импульсов
WP – защита от записи. Если на данный вывод подан логический 0, то запись в память разрешена. Если подать логическую единицу, то возможно только чтение из памяти.
Vcc
– питание микросхемы. Напряжение может быть в пределах от 2.5 вольта до 5.5 вольта.
Vss
– земля.
К микроконтроллеру микросхема подключаются следуя традициям протокола I2C, тоесть сигнальные линии подтягиваются к шине питания через резисторы номиналом 4,7к.
Неиспользуемые выводы A0, A1, A2 можно посадить на землю (IC1 в примере Attiny2313)
Организация памяти
Для того чтобы понять принцип работы с микросхемами памяти, нужно разобраться как происходит адресация внутри микросхемы. В подопытной микросхеме 24LC08 все пространство памяти поделено на 4 блока по 256 байт в каждом блоке. Каждый блок имеет свой адрес.
При обращении к микросхеме ведущее устройство (микроконтроллер) отправляет адрес устройства (он у нас фиксированный 1010) и адрес блока с которым нужно работать.
Затем отправляется адрес ячейки в которую нужно записать/прочитать данные. Что нужно сделать с данными - прочитать или записать - зависит от бита в конце посылки. Разберем на примерах.
Запись данных
Для записи в микросхему одного байта, нужно выполнить следующую последовательность действий:
- Отослать стартовый бит
- Отослать адрес микросхемы + адрес блока памяти. В конце посылки должен стоять 0 (бит записи)
- Отослать адрес ячейки памяти в которую будет производится запись
- Отослать байт данных
- Отослать стоповый бит
К примеру запишем один байт &hFF в первую ячейку памяти первого блока (адрес блока &b000 , адрес ячейки &h00 ).
$regfile
=
"2313def.dat"
$crystal
=
1000000
Config
Sda
=
Portb
.
7
"I2C Data
Config
Scl
=
Portb
.
6
"I2C Clock
Wait
1
"работа с микросхемой
I2cstart
"даем сигнал старт i2c шине
I2cwbyte
&
B10100000
I2cwbyte
&
H00
"отправляем адрес ячейки
I2cwbyte
&
HFF
"отправляем байт, который нужно записать
I2cstop
"останавливаем работу i2c
End
Постраничная запись
Для увеличения скорости записи данных существует метод постраничной записи. Одна страница - это область из 16 байт (один столбец на картинке выше). При постраничной записи адрес записываемой ячейки увеличивается автоматически, поэтому
не нужно
каждый раз вручную прописывать адрес. Для записи одной страницы отправляем адрес первой ячейки и затем 16 раз отправляем необходимые данные, причем если отправить 17 байт, то последний байт перезапишет первый и т.д. Для примера запишем первую страницу первого блока. Адрес первой ячейки
&h00
.
$regfile
=
"2313def.dat"
$crystal
=
1000000
"конфигурируем scl и sda пины
Config
Sda
=
Portb
.
7
"I2C Data
Config
Scl
=
Portb
.
6
"I2C Clock
Wait
1
"работа с микросхемой
I2cstart
"даем сигнал старт i2c шине
I2cwbyte
&
B10100000
"отправляем адрес микросхемы и адрес блока
I2cwbyte
&
H00
"отправляем адрес первой ячейки
I2cwbyte
&
HF0
"отправляем 1 байт
I2cwbyte
&
HF1
"отправляем 2 байт
I2cwbyte
&
HF2
"отправляем 3 байт
I2cwbyte
&
HF3
"отправляем 4 байт
I2cwbyte
&
HF4
"отправляем 5 байт
I2cwbyte
&
HF5
"отправляем 6 байт
I2cwbyte
&
HF6
"отправляем 7 байт
I2cwbyte
&
HF7
"отправляем 8 байт
I2cwbyte
&
HF8
"отправляем 9 байт
I2cwbyte
&
HF9
"отправляем 10 байт
I2cwbyte
&
HFA
"отправляем 11 байт
I2cwbyte
&
HFB
"отправляем 12 байт
I2cwbyte
&
HFC
"отправляем 13 байт
I2cwbyte
&
HFD
"отправляем 14 байт
I2cwbyte
&
HFE
"отправляем 15 байт
I2cwbyte
&
HFF
"отправляем 16 байт
I2cstop
"останавливаем работу i2c
End
Здесь записывается вся первая страница числами от 240 (в шестнадцатеричной системе F0) до 255 (FF).
Чтение данных
Теперь разберем как прочитать записанные в микросхему данные. Для чтения одного байта нужно проделать следующее:
- Сконфигурировать интерфейс I2C
- Отправить стартовый бит
- Отправить адрес микросхемы + адрес блока памяти откуда нужно читать
- Отправить адрес ячейки памяти
- Снова отправить стартовый бит
- Отправить адрес микросхемы и адрес блока памяти с битом «чтение»
- Получить байт
- Отправить стоповый бит
Чтение первой ячейки первого блока будет выглядеть так:
$regfile
=
"2313def.dat"
$crystal
=
1000000
Dim
A
As
Byte
"переменная для хранения прочитанного байта
"конфигурируем scl и sda пины
Config
Sda
=
Portb
.
7
"I2C Data
Config
Scl
=
Portb
.
6
"I2C Clock
Wait
1
"работа с микросхемой
I2cstart
"даем сигнал старт i2c шине
I2cwbyte
&
B10100000
"отправляем адрес микросхемы и адрес блока
I2cwbyte
&
H00
"отправляем адрес ячейки
Продолжу рассказывать про приборную панель для мотоцикла. Это замечательное устройство содержит одометр, то есть, счётчик пройденного пути в километрах, а у того есть плохое свойство - он должен сохранять данные и при выключенном питании. Ой, ещё есть моточасы, их тоже надо хранить как-то энергозависимо.
Внутри Ардуины есть EEPROM, конечно же. Много места не надо, чтобы хранить пяток длинных целых, но есть нюанс. EEPROM имеет слишком ограниченный ресурс на запись. Хотелось бы писать данные раз в несколько секунд хотя бы. Ресурс же EEPROM позволяет это делать вполне обозримое время, то есть, встроенная память явно не вечна.
Сначала я хотел обмануть судьбу записывая структурку данных в разные места 1К памяти чипа по кругу. Упёрся в то, что указатель надо где-то хранить тоже, а данные достаточно случайные, чтобы использовать какой-то маркер для последовательного поиска.
Необходимость хранения указателя можно обмануть разными способами. Например так:
Struct MarkedSavedData { byte marker; // показывает, занято место или нет. struct SavedData { // Собственно данные для сохранения } } data;
Структуркой MarkedSavedData заполняется eerpom или флеш или что-то по кругу. Чтобы не писать указатель, в свободных записях делаем data.marker=0x00, а в занятой текущей data.marker=0xff, например. В процессе работы, конечно же, запись идёт по указателям, а при старте контроллера просто поиском по всей памяти ищется структура с data.marker==0xff - это последние правильные данные. Плохо, что каждый раз две записи получаются тк надо обнулить data.marker освобождаемой записи.
Есть вариант с последовательным счётчиком.
Struct MarkedSavedData { unsugned int counter; // последовательный номер записи. struct SavedData { // Собственно данные для сохранения } } data;
На каждую запись увеличивать счётчик на единицу забив на переполнение. При старте контроллера искать самый большой счётчик с учётом возможного переполнения, что не так уж и трудно, а сэкономить sram можно сделав для этого функцию и поместив промежуточные структурки в стеке в локальных переменных её.
Всё это хорошо, но это припарки.
Пример прилагается вот такой.
#include "FM24I2C.h"
// Объект для платы. Адрес в i2c.
FM24I2C fm(0x57);
void setup() {
Wire.begin();
Serial.begin(9600);
char str1="12345678901234567890";
char str2="qwertyuiopasdfghjklzxcvbnm";
int a1=0x00; // Первый в FRAM
int a2=0x40; // Второй адрес в FRAM
fm.pack(a1,str1,strlen(str1)+1); // Пишем в память
delay(5);
fm.pack(a2,str2,strlen(str2)+1); // Пишем вторую строку
delay(5);
char buf;
fm.unpack(a2,buf,strlen(str2)+1); // Читаем вторую
Serial.println(str2);
fm.unpack(a1,buf,strlen(str1)+1); // Читаем первую
Serial.println(str1);
}
Протокол i2c для FRAM сильно проще, чем для EEPROM. Память работает быстрее передачи данных по шине и можно лить хоть все 2К ардуининых мозгов за один раз. Польза от моего кода хоть в том, что нет лишнего разбиения на блоки по 32 байта или вообще побайтной передачи.
Class FM24I2C {
private:
int id;
public:
FM24I2C(int id_addr);
~FM24I2C();
void pack(int addr, void* data, int len); // Упаковать данные в FRAM
int unpack(int addr, void* data, int len); // Распаковать из FRAM. Возвращает количество переданных байтов.
// Это уже специально для меня, пишет беззнаковые длинные целые.
void inline writeUnsignedLong(int addr, unsigned long data) {
pack(addr, (void*)&data, sizeof(unsigned long));
}
// И читает.
unsigned long inline readUnsignedLong(int addr) {
unsigned long data;
return unpack(addr, (void*)&data, sizeof(unsigned long)) == sizeof(unsigned long) ? data: 0UL;
}
// Можно для других типов сделать чтение/запись, но мне было не нужно, а флеш занимает.
// Каждый же может унаследовать класс и дописать сам.
};
Кода же немножко совсем.
Void FM24I2C::pack(int addr, void* data, int len) {
Wire.beginTransmission(id);
Wire.write((byte*)&addr,2);
Wire.write((byte*)data,len); // Наверное, стоит всё же unsigned int использовать:)
Wire.endTransmission(true);
}
int FM24I2C::unpack(int addr, void* data, int len) {
int rc;
byte *p;
Wire.beginTransmission(id);
Wire.write((byte*)&addr,2);
Wire.endTransmission(false);
Wire.requestFrom(id,len);
// Здесь можно поспорить про замену rc на p-data:)
for (rc=0, p=(byte*)data; Wire.available() && rc < len; rc++, p++) {
*p=Wire.read();
}
return(rc);
}
Так как на модуле, кроме чипа и разъёмов, практически ничего нет, уже хочу купить несколько микросхем. Нравятся.
Подключить внешнюю EEPROM память к Arduino довольно просто, и проще всего сделать это через шину I 2 C. Есть много EEPROM, но 24LS256 или 24LC256 хороши простотой в использовании и относительной дешевизной (85 евро центов у моего поставщика). Емкость 24LC256 - 256 килобит данных (то есть 32 килобайта). 24LS256 также может работать на 3.3В, что удобно при использовании Lilypad или Pro Mini 3.3V. В 24LS256 3 вывода используется для выбора его адреса, так что вы можете использовать до восьми микросхем на одной шине.
Адрес 24LS256: 1010A2A1A0. Если вы работаете только с 1 EEPROM, проще всего подключить A2-A0 к земле. Это дает адрес 1010000, 0 × 50 Hex. При чтении и записи в EEPROM надо понимать, что его емкость 32 Кб (фактически 32767) и одного байта не достаточно для адресации всей памяти.
Так, когда кто-то хочет послать запросы чтения и/или записи, необходимо отправить два байта - один MSB или верхнюю часть адреса (8 бит слева направо), а следующий LSB или нижнюю часть адреса (последние 8 бит слева направо).
Если, например, кто-то хочет использовать адрес 21000, это делается так: в двоичной системе 21000 это 0101001000001000. Разбейте его на части 01010010 и 00001000, а затем преобразуйте двоичные значения обратно в десятичное для отправки Wire.send ().
Это звучит сложно, но на самом деле все очень просто. Есть два оператора, чтобы сделать это. Первый >>, также известный как "сдвиг вправо". Эта команда берет высшую (левую) часть байта и убирает нижнюю часть, оставляя только первые 8 бит. Чтобы получить нижний (правый) конец адреса, можно использовать оператор &, также известный как ”побитовое И”. Этот оператор при использовании с 0xFF даст нижний бит.
Запись данных на 24LS256
Запись данных довольно проста. Для начала инициализируем шину I2C:
Wire.beginTransmission(0x50); // пины A0~A2 сажаем на GND
Затем отправляем данные. Первым делом отправляем два байта адреса (25000), куда мы хотим записать данные.
Wire.send(21000 >>
Затем отправляем байт для хранения по адресу 21000, а затем закрываем соединение:
Wire.send(15); // посылаем число 15
Wire.endTransmission();
Чтение данных из 24LS256
Чтение более менее похоже. Для начала, инициализируйте соединение и укажите адрес данных для чтения:
Wire.send(21000 >> 8); // посылаем старший байт MSB адреса
Wire.send(21000 & 0xFF); // посылаем младший байт LSB адреса
Wire.endTransmission();
Затем установите номер байтов данных, для чтения начиная с текущего адреса:
Wire.beginTransmission(0x50); // выбор адреса
Wire.requestFrom(0x50,1); // считываем один байт данных
Wire.receive(inbyte);
Здесь “inbyte” является переменной, выбранной для хранения данных, извлеченных из EEPROM.
Шина I2C подразумевает, что разные устройства могут быть подключены к одной линии. Верхний рисунок показывает это с двумя EEPROM. Ключевую роль играет то, что каждый из них имеет свой собственный адрес. На рисунке я решил использовать адреса 0 × 50 и 0 × 51. Первый получается при подключении A0-A2 одной микросхемы на землю, но при подключении A0 второй микросхемы к Vcc (Высокий) для второго чипа. В результате адрес 1010001 = 0x51
