Иногда при разработке устройства возникает потребность сохранять какие-либо данные в энергонезависимую память.  В таких случаях обычно используют внутреннюю EEPROM микроконтроллера. Если её недостаточно, то как правило применяются внешние микросхемы EEPROM из серии 24lxx. Микросхемы этой серии очень популярны. Чаще всего их можно встретить в старых мобильных телефонах, некоторых материнских платах, картриджах от принтеров да еще много где. Цена данных микросхем тоже очень привлекательная. Например 24LC16 у нас стоит 11 рублей.
Данная микросхема выпускается в различных корпусах, самые популярные из которых это DIP и SOIC. Микросхема имеет следующую распиновку:

24LC16

Как видите выводов совсем немного. Итак попробуем разобраться для что к чему.
A0, A1, A2 — в данной микросхеме не используются. Их можно подсоединить к земле или к плюсу питания. В некоторых других микросхемах серии  24lxx, этими выводами можно задавать адрес микросхемы, для того чтобы можно было подсоединить на одну шину i2c аж сразу 8 микрух памяти.
Vss —  земля.
SDA — линия данных
SCL — линия  тактовых импульсов
WP — Защита от записи. Когда на данном выводе логический  0, то запись в память разрешена. Если подать логическую единицу, то возможно только чтение из памяти. 
Vcc — питание микросхемы.   Согласно даташиту питается она напряжением от 2.5 вольта  до 5.5 вольта.

Подключение к контроллеру.
Подключить память к МК очень просто. Из обвязки потребуются только пара резисторов сопротивлением около 4.7 кОм.

24LC16 и AVR

Программное обеспечение

Для работы с памятью была разработана библиотека реализующая следующие функции:

i2c_init — настраивает скорость тактовых импульсов идущих по линии SCL.

Микросхема 24LC16 поддерживает частоту до 400 кГц.  Рассчитать частоту можно так:

CPU Clock frequency — частота на которой работает микроконтроллер

TWBR — число записанное в одноименный регистр.

TWPS —  предделитель. Значения предделителя задаются битами TWPS1 и TWPS0 в регистре TWSR

Для  контроллера Atmega 32 справедлива такая таблица:

i2c_start — отсылает стартовую посылку

i2c_stop — отсылает стоповую посылку

i2c_send — отсылает байт

i2c_recive — принимает байт

i2c_recive_last — принимает последний байт. Отличие от предыдущей функции состоит в том, что когда байт принят, микроконтроллер не отсылает бит подтверждения. Если при приёме последнего байта использовать i2c_recive то линия SDA останется прижатой к земле.

Запись данных в микросхему памяти

Записывать данные можно как в произвольном порядке так и постранично. Поскольку на шине i2c могут быть сразу несколько устройств, то для того чтобы обратится к какому либо устройству нужно знать его семибитный адрес. Адрес микросхемы 24LC16  в двоичном виде выглядит так:

Биты A,B,C служат для выбора блока памяти. Блоков памяти в микросхеме 8 штук по 256 байт каждый. Соответственно биты  ABC принимают значения от 000 до 111.

Для того чтоб записать в микросхему байт нужно выполнить следующую последовательность действий:

  1. Инициализировать интерфейс i2c
  2. Отослать стартовую посылку
  3. Отослать адрес микросхемы+адрес блока памяти
  4. Отослать адрес ячейки памяти в которую будет производится запись
  5. Отослать байт данных
  6. Отослать стоповую посылку

Пример: Нужно записать байт 0xFA по адресу 0x101.

rcall i2c_init //Инициализируем интерфейс i2c
rcall i2c_start // Отправляем стартовую посылку
ldi temp,0b
10100010 //Адрес микросхемы где:
// 1010 - адрес микросхемы
//001 - адрес блока памяти (Ячейка 0x101 принадлежит блоку 1)
//0 - бит чтения/записи. 0 - запись , 1 - чтение
rcall i2c_send
ldi temp,1  //Адрес ячейки памяти. (блок 1, ячейка 1)
rcall i2c_send
ldi temp,0xFA //Загружаем в регистр байт который нужно записать
rcall i2c_send //Записываем байт

rcall i2c_stop  //Отправляем стоповую посылку

Записывать данные в память можно не только побайтно но и постранично. Размер страницы — 16 байт.  Постараничная запись подразумевает следующее: Отправляем адрес нулевого байта нужной страницы и после этого 16 раз отправляем нужные данные. Счётчик адреса будет увеличивать на единицу автоматически. Если отправить данные в 17-й раз, то будет перезаписан нулевой байт, если отправить байт 18-й раз , то он затрет байт номер 1 итд.

Пример:  Требуется записать первую страницу блока 0.

rcall i2c_init //Инициализируем интерфейс i2c
rcall i2c_start // Отправляем стартовую посылку
ldi temp,0b
10100000 //Адрес микросхемы где:
// 1010 - адрес микросхемы
//000 - адрес блока памяти (нас интересует нулевой блок)
//0 - бит чтения/записи. 0 - запись , 1 - чтение
rcall i2c_send
ldi temp,16  //Адрес первой страницы
rcall i2c_send
ldi temp,0x01  //Загружаем в регистр байт номер 0
rcall i2c_send //Записываем байт
ldi temp,0x02  //Загружаем в регистр байт номер 1
rcall i2c_send //Записываем байт
/// тут пишем остальные байты.....
ldi temp,0x0E  //Загружаем в регистр байт номер 14
rcall i2c_send //Записываем байт
ldi temp,0x0F  //Загружаем в регистр байт номер 15
rcall i2c_send //Записываем байт

rcall i2c_stop  //Отправляем стоповую посылку

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

  1. Инициализировать интерфейс i2c (если он не инициализировался ранее)
  2. Отправить стартовую посылку
  3. Отправить адрес микросхемы и адрес блока памяти откуда будем читать
  4. Отправить адрес ячейки памяти
  5. Отправить стартовую посылку повторно
  6. Отправить адрес микросхемы и адрес блока памяти с битом «чтение»
  7. Получить байт
  8. Отправить стоповую посылку

Пример: Нужно прочитать байт находящийся по адресу 0x341

rcall i2c_init //Инициализируем интерфейс i2c
rcall i2c_start // Отправляем стартовую посылку
ldi temp,0b10100110 //Адрес микросхемы + адрес 3-го блока памяти.
//Бит чтение/запись по прежнему 0 !
rcall i2c_send
ldi temp,0x41 //Адрес ячейки памяти
rcall i2c_send
rcall i2c_start //Повторная отправка стартовой посылки
ldi temp,0b10100111 //Адрес микросхемы+адрес блока памяти+бит чтения/записи стал 1
rcall i2c_send     //теперь можно читать данные
rcall i2c_recive_last  //Читаем байт. Первый и последний.

rcall i2c_stop   //Отправляем стоповую посылку

Чтение может производится последовательно байт за байтом, т.е. просто вызывать i2c_recive столько сколько нужно. Команду увеличения адреса на единицу посылать не нужно. Переключать адреса блоков при последовательном чтении так же не нужно. Т.е. можно взять и разом прочитать всю микросхему без всяких проблем.

Библиотека для работы с i2c разрабатывалась и была испытана на микроконтроллере Atmega32. Я думаю что она будет работать на многих других контроллерах без каких либо изменений. Естественно в контроллере должна быть аппаратная поддержка i2c или как его еще называют TWI. Конечно реализовать i2c можно и программно, но я не стал заморачиваться да и не было нужды. Демонстрационный пример  представляет собой программу которая записывает по первым 16 адресам байты от 0 до 15, а после записи выводит их в порт A. Наблюдать как это работает можно не только в живую но и в Proteus’е.

Ну и напоследок прикладываю осциллограмму:

Вот так выглядит шина i2c глазами моего осциллографа :-)
Все вопросы и предложения жду в комментариях.

P.S. для понимания работы шины рекомендую ознакомится со статьёй Di Halt’a

Скачать исходник  + демонстрационный пример