Подключить внешнюю 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
Для того чтобы полностью разобраться с Two-Wire Interface (TWI) , пишем с нуля в AVR STUDIO процедуры инициализации, чтения и записи. Подробно останавливаемся на каждом шаге и разбираемся. Затем промоделируем все в Proteus.
I. Кратко теория
Аппаратный модуль TWI и протокол I2C
В микроконтроллеры серии MEGA входит модуль TWI, с помощью которого мы будем работать с шиной I2C. Модуль TWI по сути является посредником между нашей программой и подключаемым устройством (память I2C EEPROM, например).
Структура модуля TWI в микроконтроллерах AVR
Шина I2C состоит из двух проводов:
- SCL (Serial Clock Line) – линия последовательной передачи тактовых импульсов.
- SDA (Serial Data Line) – линия последовательной передачи данных.
К этой шине мы можем одновременно подключить до 128 микросхем.
Подключения к шине TWI
Наш контроллер будем называть ведущим, а все подключаемые микросхемы ведомыми. Каждый ведомый имеет определенный адрес, зашитый на заводе в ходе изготовления (кстати, граница в 128 микросхем как раз и определяется диапазоном возможных адресов). С помощью этого адреса мы и можем работать с каждый ведомым индивидуально, хотя все они подключены к одной шине одинаковым образом. Из нашей программы мы управляем модулем TWI, а этот модуль берет на себя дергание ножками SCL и SDA.
Как видно на блок-схеме, TWI условно состоит из четырех блоков. Вначале нам нужно будет настроить Генератор скорости связи, и мы сразу забудем про него. Основная работа – с Блоком управления.
Блок шинного интерфейса управляется Блоком управления, т.е. непосредственно с ним мы контактировать не будем. А Блок сравнения адреса нужен, чтобы задать адрес на шине I2C, если тока наш контроллер будет подчиненным устройством(ведомым) от другого какого-то контроллера или будет приемником от другого ведущего (как в статье Налаживаем обмен данными между двумя контроллерами по шине I²C на моем блоге). В этой статье он нам не нужен. Если хотите, почитайте про него в любом даташите контроллера серии MEGA.
Итак, наша задача сейчас разобраться с регистрами, входящими в Генератор скорости связи и Блок управления:
Регистр скорости связи TWBR
Регистр управления TWCR
Регистр статуса(состояния) TWSR
Регистр данных TWDR
И все, разобравшись всего лишь с 4-мя регистрами, мы сможем полноценно работать с внешней памятью EEPROM и вообще, обмениваться данными по I2C с любым другим устройством.
Генератор скорости связи и Регистр скорости связи TWBR
Блок генератора скорости связи управляет линией SCL, а именно периодом тактовых импульсов. Управлять линией SCL может только ведущий. Период SCL управляется путем установки регистра скорости связи TWI (TWBR) и бит предделителя в регистре статуса TWI (TWSR).
Частота SCL генерируется по следующей формуле:
F SCL = F ЦПУ /,
- TWBR — значение в регистре скорости связи TWI;
- TWPS — значение бит предделителя в регистре статуса TWI (TWSR).
- F цпу – тактовая частота ведущего
- F SCL – частота тактовых импульсов линии SCL
Настройка TWBR нужна, т.к. ведомая микросхема обучена обмениваться данными на определенной частоте. Например, в Proteus, введите в поиск I2CMEM, увидите обилие микросхем памяти, в основном у них указаны частоты 100 и 400Khz.
Ну вот, подставляя в формулу частоты F ЦПУ и F SCL , мы сможем найти оптимальное значение для регистра TWBR.
TWPS – это 2-битное число , первый бит – это разряд TWPS0, второй – TWPS1 в регистре статуса TWSR. Задавая Предделитель скорости связи 4 TWPS , мы можем понижать значение TWBR (т.к. TWBR – это байт, максимальное значение 255). Но обычно это не требуется, поэтому TWPS обычно задается 0 и 4 TWPS = 1. Гораздо чаще, наоборот, мы упираемся в нижний диапазон регистра TWBR. Если TWI работает в ведущем режиме, то значение TWBR должно быть не менее 10. Если значение TWBR меньше 10, то ведущее устройство шины может генерировать некорректные сигналы на линиях SDA и SCL во время передачи байта.
| Частота ЦПУ, МГц | TWBR | TWPS | Частота SCL, КГц |
| 16.0 | 12 | 0 | 400 |
| 16.0 | 72 | 0 | 100 |
| 14.4 | 10 | 0 | 400 |
| 14.4 | 64 | 0 | 100 |
| 12.0 | 52 | 0 | 100 |
| 8.0 | 32 | 0 | 100 |
| 4.0 | 12 | 0 | 100 |
| 3.6 | 10 | 0 | 100 |
Ну вот, настройка TWI в этом и заключается:
задание значения предделителя ( в регистре статуса TWSR)
Регистр состояния TWI — TWSR
| Разряд | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
| TWS7 | TWS6 | TWS5 | TWS4 | TWS3 | — | TWPS1 | TWPS0 | |
| Чтение/запись | Чт. | Чт. | Чт. | Чт. | Чт. | Чт. | Чт./Зп. | Чт./Зп. |
| Исх. значение | 1 | 1 | 1 | 1 | 1 | 0 | 0 | 0 |
задание скорости связи (TWBR, Регистр скорости связи).
Регистр скорости связи шины TWI — TWBR
| Разряд | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
| TWBR7 | TWBR6 | TWBR5 | TWBR4 | TWBR3 | TWBR2 | TWBR1 | TWBR0 | |
| Чтение/запись | Чт./Зп. | Чт./Зп. | Чт./Зп. | Чт./Зп. | Чт./Зп. | Чт./Зп. | Чт./Зп. | Чт./Зп. |
| Исх. значение | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
Блок управления
Регистр TWCR предназначен для управления работой TWI. Он используется для разрешения работы TWI, для инициации сеанса связи ведущего путем генерации условия СТАРТ на шине, для генерации подтверждения приема, для генерации условия СТОП и для останова шины во время записи в регистр TWDR. Он также сигнализирует о попытке ошибочной записи в регистр TWDR, когда доступ к нему был запрещен.
Регистр управления шиной TWI — TWCR
| Разряд | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
| TWINT | TWEA | TWSTA | TWSTO | TWWC | TWEN | — | TWIE | |
| Чтение/запись | Чт./Зп. | Чт./Зп. | Чт./Зп. | Чт./Зп. | Чт. | Чт./Зп. | Чт. | Чт./Зп. |
| Исх. значение | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
Разряд 7 — TWINT: Флаг прерывания TWI
Этот флаг устанавливается аппаратно, если TWI завершает текущее задание (к примеру, передачу, принятие данных) и ожидает реакции программы. Линия SCL остается в низком состоянии, пока установлен флаг TWINT. Флаг TWINT сбрасывается программно путем записи в него логической 1. Очистка данного флага приводит к возобновлению работы TWI, т.е. программный сброс данного флага необходимо выполнить после завершения опроса регистров статуса TWSR и данных TWDR.
Разряд 6 — TWEA: Бит разрешения подтверждения
Бит TWEA управляет генерацией импульса подтверждения. Как видно в таблице, по умолчанию он сброшен. Останавливаться на нем не буду, он в данной статье не пригодится.
Разряд 5 — TWSTA: Бит условия СТАРТ
Мы должны установить данный бит при необходимости стать ведущим на шине I2C. TWI аппаратно проверяет доступность шины и генерирует условие СТАРТ, если шина свободна. Мы проверяем это условие (по регистру статуса, будет далее) и если шина свободна, то мы можем начинать с ней работать. Иначе нужно будет подождать, пока шина освободится.
Разряд 4 — TWSTO: Бит условия СТОП
Установка бита TWSTO в режиме ведущего приводит к генерации условия СТОП на шине I2C. Если на шине выполняется условие СТОП, то бит TWSTO сбрасывается автоматически и шина освобождается.
Разряд 3 — TWWC: Флаг ошибочной записи
Бит TWWC устанавливается при попытке записи в регистр данных TWDR, когда TWINT имеет низкий уровень. Флаг сбрасывается при записи регистра TWDR, когда TWINT = 1.
Разряд 2 — TWEN: Бит разрешения работы TWI
Бит TWEN разрешает работу TWI и активизирует интерфейс TWI. Если бит TWEN установлен, то TWI берет на себя функции управления линиями ввода-вывода SCL и SDA. Если данный бит равен нулю, то TWI отключается и все передачи прекращаются независимо от состояния работы.
Разряд 1 — Резервный бит
Разряд 0 — TWIE: Разрешение прерывания TWI
Если в данный бит записана лог. 1 и установлен бит I в регистре SREG (прерывания разрешены глобально), то разрешается прерывание от модуля TWI (ISR (TWI_vect) ) при любом изменении регистра статуса.
Регистр состояния TWI – TWSR
| Разряд | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
| TWS7 | TWS6 | TWS5 | TWS4 | TWS3 | — | TWPS1 | TWPS0 | |
| Чтение/запись | Чт. | Чт. | Чт. | Чт. | Чт. | Чт. | Чт./Зп. | Чт./Зп. |
| Исх. значение | 1 | 1 | 1 | 1 | 1 | 0 | 0 | 0 |
Разряды 7..3 — TWS: Состояние TWI
Данные 5 бит отражают состояние логики блока TWI и шины I2C. Диапазон кодов состояния 0b0000 0000 – 0b1111 1000, или с 0x00 до 0xF8. Привожу их ниже:
// TWSR values (not bits) // (taken from avr-libc twi.h - thank you Marek Michalkiewicz) // Master (Ведущий) #define TW_START 0x08 //условие СТАРТ #define TW_REP_START 0x10 //условие ПОВТОРНЫЙ СТАРТ (повтор условия начала передачи) // Master Transmitter (Ведущий в роли передающего) #define TW_MT_SLA_ACK 0x18 //Ведущий отправил адрес и бит записи. Ведомый подтвердил свой адрес #define TW_MT_SLA_NACK 0x20 //Ведущий отправил адрес и бит записи. Нет подтверждения приема (ведомый с таким адресом не найден) #define TW_MT_DATA_ACK 0x28 //Ведущий передал данные и ведомый подтвердил прием. #define TW_MT_DATA_NACK 0x30 //Ведущий передал данные. Нет подтверждения приема #define TW_MT_ARB_LOST 0x38 //Потеря приоритета // Master Receiver (Ведущий в роли принимающего) #define TW_MR_ARB_LOST 0x38 //Потеря приоритета #define TW_MR_SLA_ACK 0x40 // Ведущий отправил адрес и бит чтения. Ведомый подтвердил свой адрес #define TW_MR_SLA_NACK 0x48 //Ведущий отправил адрес и бит чтения. Нет подтверждения приема (ведомый с таким адресом не найден) #define TW_MR_DATA_ACK 0x50 //Ведущий принял данные и передал подтверждение #define TW_MR_DATA_NACK 0x58 //Ведущий принял данные и не передал подтверждение // Slave Transmitter (Ведомый в роли передающего) #define TW_ST_SLA_ACK 0xA8 //Получение адреса и бита чтения, возвращение подтверждения #define TW_ST_ARB_LOST_SLA_ACK 0xB0 //Потеря приоритета, получение адреса и бита чтения, возвращение подтверждения #define TW_ST_DATA_ACK 0xB8 //Данные переданы, подтверждение от ведущего принято #define TW_ST_DATA_NACK 0xC0 //Данные переданы. Нет подтверждения приема от ведущего. #define TW_ST_LAST_DATA 0xC8 //Последний переданный байт данных, получение подтверждения // Slave Receiver (Ведомый в роли принимающего) #define TW_SR_SLA_ACK 0x60 //Получение адреса и бита записи, возвращение подтверждения #define TW_SR_ARB_LOST_SLA_ACK 0x68 //Потеря приоритета, получение адреса и бита записи, возвращение подтверждения #define TW_SR_GCALL_ACK 0x70 //Прием общего запроса, возвращение подтверждения #define TW_SR_ARB_LOST_GCALL_ACK 0x78 //Потеря приоритета, прием общего запроса, возвращение подтверждения #define TW_SR_DATA_ACK 0x80 // Прием данных, возвращение подтверждения #define TW_SR_DATA_NACK 0x88 //Данные переданы без подтверждения. #define TW_SR_GCALL_DATA_ACK 0x90 //Прием данных при общем запросе, возвращение подтверждения #define TW_SR_GCALL_DATA_NACK 0x98 // Прием данных при общем запросе, без подтверждения #define TW_SR_STOP 0xA0 //Условие СТОП // Misc (Ошибки интерфейса) #define TW_NO_INFO 0xF8 //Информация о состоянии отсутствует #define TW_BUS_ERROR 0x00 //Ошибка шины
Если мы работаем с пассивным ведомым (т.е. это не другой контроллер AVR, а микросхема памяти или например, часы RTC), то коды состояний из разделов Slave Transmitter (Ведомый в роли передающего) и Slave Receiver (Ведомый в роли принимающего) нам не понадобятся, поскольку единственная «разумная» микросхема у нас – это Ведущий (наш контроллер).
Проверяя регистр статуса после каждой выполненной операции с шиной, мы можем контролировать обмен информацией. Например, будем точно знать – записались ли данные во внешнюю память или нет.
Регистр данных шины TWI — TWDR
| Разряд | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
| TWD7 | TWD6 | TWD5 | TWD4 | TWD3 | TWD2 | TWD1 | TWD0 | |
| Чтение/запись | Чт./Зп. | Чт./Зп. | Чт./Зп. | Чт./Зп. | Чт./Зп. | Чт./Зп. | Чт./Зп. | Чт./Зп. |
| Исх. значение | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
В режиме передатчика регистр TWDR содержит байт для передачи. В режиме приемника регистр TWDR содержит последний принятый байт. Будьте внимательны, после аппаратной установки флага TWINT, регистр TWDR не содержит ничего определенного.
Ну вот, этих знаний более чем достаточно, чтобы работать с I2C EEPROM. Теперь переходим непосредственно к программной части. Я решил пояснения писать прямо в коде в виде комментариев.
II. Программа
Все функции (инициализация TWI, чтение, запись внешней памяти) я вынесу в отдельные файлы, как это и принято делать, i2c_eeprom.c и i2c_eeprom.h.
#define false 0 #define true 1 //#define slaveF_SCL 100000 //100 Khz #define slaveF_SCL 400000 //400 Khz #define slaveAddressConst 0b1010 //Постоянная часть адреса ведомого устройства #define slaveAddressVar 0b000 //Переменная часть адреса ведомого устройства //Разряды направления передачи данных #define READFLAG 1 //Чтение #define WRITEFLAG 0 //Запись void eeInit(void); //Начальная настройка TWI uint8_t eeWriteByte(uint16_t address,uint8_t data); //Запись байта в модуль памяти EEPROM uint8_t eeReadByte(uint16_t address); //Чтение байта из модуля памяти EEPROM // TWSR values (not bits) // (taken from avr-libc twi.h - thank you Marek Michalkiewicz) // Master #define TW_START 0x08 #define TW_REP_START 0x10 // Master Transmitter #define TW_MT_SLA_ACK 0x18 #define TW_MT_SLA_NACK 0x20 #define TW_MT_DATA_ACK 0x28 #define TW_MT_DATA_NACK 0x30 #define TW_MT_ARB_LOST 0x38 // Master Receiver #define TW_MR_ARB_LOST 0x38 #define TW_MR_SLA_ACK 0x40 #define TW_MR_SLA_NACK 0x48 #define TW_MR_DATA_ACK 0x50 #define TW_MR_DATA_NACK 0x58 // Slave Transmitter #define TW_ST_SLA_ACK 0xA8 #define TW_ST_ARB_LOST_SLA_ACK 0xB0 #define TW_ST_DATA_ACK 0xB8 #define TW_ST_DATA_NACK 0xC0 #define TW_ST_LAST_DATA 0xC8 // Slave Receiver #define TW_SR_SLA_ACK 0x60 #define TW_SR_ARB_LOST_SLA_ACK 0x68 #define TW_SR_GCALL_ACK 0x70 #define TW_SR_ARB_LOST_GCALL_ACK 0x78 #define TW_SR_DATA_ACK 0x80 #define TW_SR_DATA_NACK 0x88 #define TW_SR_GCALL_DATA_ACK 0x90 #define TW_SR_GCALL_DATA_NACK 0x98 #define TW_SR_STOP 0xA0 // Misc #define TW_NO_INFO 0xF8 #define TW_BUS_ERROR 0x00
Чтобы было легче воспринимать нижеследующий код, приведу здесь теоретические примеры осциллограмм при обмене данными между Ведущим и Ведомым по шине I2C (взял в книжке , в более высоком разрешении найдете по адресу, указанном в конце статьи):
#include Ну вот, самые главные функции мы написали. На этой базе можно написать функции для чтения\записи массива байтов. Также можно добавить прерывание ISR(TWI_INT), которое будет срабатывать при каждом изменении регистра статуса. Я скажу только пару слов об этом, поскольку разобравшись в вышеизложенном, вам не составит труда реализовать их самому. Итак, пару слов о чтении\записи массива байтов. Очень просто взять и вогнать в цикл функции eeReadByte\eeWriteByte.
Это даже будет работать
. Но, посмотрите, TWI каждый раз будет формировать условие СТАРТ, устанавливать связь с ведомым, отсылать адрес чтения\записи… Словом, огромная потеря времени. Вы же не покупаете продукты в магазине по частям
, нет — вы складываете все продукты (байты) в кулек (в массив) и несете домой. Дак давайте также сложим все наши байты в кулек! Изменения в новой функции eeWriteBytes
будут следующими, часть кода затаскиваем в цикл: /*****ЗАПИСЫВАЕМ БАЙТЫ ДАННЫХ********/
//Аналогично, как и передавали адрес, передаем байты данных
for(i=0;i В процедуре чтения изменения будут чуточку сложнее, поскольку между считыванием байтов данных должно быть подтверждение от ведущего, а после считывания последнего
байта подтверждения быть не должно, далее идет условие завершения передачи (условие СТОП). Про прерывание ISR(TWI_INT) говорить ничего не буду, просто приведу пример использования (обычно этого достаточно, сразу становится все понятно): ISR(TWI)
{
switch(TWSR & 0xF8)
{
case TW_START:
lcd_puts("TW_START\n");
break;
case TW_REP_START:
lcd_puts("TW_REP_START\n");
break;
case TW_MT_SLA_ACK:
lcd_puts("TW_MT_SLA_ACK\n");
break;
case TW_MT_DATA_ACK:
lcd_puts("TW_MT_DATA_ACK\n");
break;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//и т.д.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
}
} Все, остается создать проект в AVR STUDIO: В настройках проекта укажите какой-нибудь MEGA (atmega16 например), подключите файлы i2c_eeprom.c и i2c_eeprom.h. #define F_CPU 16000000UL
#include В программе я явно указал частоту тактирования моего контроллера 16 Mhz. Далее, в Proteus, мы выберем какую-нибудь микросхему внешней памяти I2C EEPROM. Не забудьте после этого сравнить настройки в i2c_eeprom.h с параметрами выбранной микросхемы (slaveF_SCL
, slaveAddressConst
– достоверную информацию всегда можно узнать из даташитов). Итак, остается собрать проект и переходим к моделированию.. III.
Моделируем работу с I2C EEPROM в Proteus
Добавляем на схему ATmega16, 2 резистора для подтяжки шины I2C (см. схему в начале статьи). Из вкладки виртуальные инструменты возьмите Осциллограф и I2C-Отладчик. Для выбора памяти введите в поиск I2CMEMS в окне выбора устройств: Из всего списка я выбрал 24LC64 с объемом памяти 64 КБ и частотой работы с шиной I2C 400 КГц. В настройках контроллера укажите прошивку, частоту тактирования 16 МГц и не забудьте выставить CKSEL-фьюзы для кристалла. В настройках I2C-отладчика укажите, что тактовая частота импульсов шины 400 КГц. Запускаем моделирование.. Видно, что в PORTA записалось число 0b0000’1010 или 0x0A или 10, т.е. переменная uint8_t byte
содержит верное значение после чтения памяти 24LC64 по адресу 0х19. Давайте посмотрим подробнее, что делает наша программа, взглянем на лог I2C-отладчика: Теперь можно опуститься еще на уровень ниже и посмотреть на осциллограмму: Логика, думаю, понятна. Так можно просмотреть и всю осциллограмму, проверить работу I2C в реальной ситуации, а не в режиме симуляции. Когда нужно длительное время хранить какие-нибудь рабочие данные, не боясь их потерять, используют штатную, встроенную в микроконтроллер, 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) и адрес блока с которым нужно работать.
Затем отправляется адрес ячейки в которую нужно записать/прочитать данные. Что нужно сделать с данными - прочитать или записать - зависит от бита в конце посылки. Разберем на примерах.
Запись данных
Для записи в микросхему одного байта, нужно выполнить следующую последовательность действий:
К примеру запишем один байт &hFF
в
первую ячейку памяти первого блока (адрес блока &b000
, адрес ячейки &h00
).
$regfile
=
"2313def.dat"
Постраничная запись
Для увеличения скорости записи данных существует метод постраничной записи. Одна страница - это область из 16 байт (один столбец на картинке выше). При постраничной записи адрес записываемой ячейки увеличивается автоматически, поэтому
$regfile
=
"2313def.dat"
I2cwbyte
&
HF0
"отправляем 1 байт
Чтение данных
Теперь разберем как прочитать записанные в микросхему данные. Для чтения одного байта нужно проделать следующее:
Чтение первой ячейки первого блока будет выглядеть так:
$regfile
=
"2313def.dat"
Продолжу рассказывать про приборную панель для мотоцикла. Это замечательное устройство содержит одометр, то есть, счётчик пройденного пути в километрах, а у того есть плохое свойство - он должен сохранять данные и при выключенном питании. Ой, ещё есть моточасы, их тоже надо хранить как-то энергозависимо. Внутри Ардуины есть EEPROM, конечно же. Много места не надо, чтобы хранить пяток длинных целых, но есть нюанс. EEPROM имеет слишком ограниченный ресурс на запись. Хотелось бы писать данные раз в несколько секунд хотя бы. Ресурс же EEPROM позволяет это делать вполне обозримое время, то есть, встроенная память явно не вечна. Необходимость хранения указателя можно обмануть разными способами. Например так: 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);
}
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 каждые несколько минут (или несколько секунд), вы можете столкнуться с проблемой износа ячеек EEPROM. Чтобы избежать этого, требуется снижать частоту записей в ячейку. Для некоторых типов EEPROM даже частота записи чаще чем один раз в час может быть проблемой.
Но проблема в том, что EEPROM имеет ограниченный ресурс числа записей. После 100,000 или миллиона записей (зависит от конкретного чипа), некоторые из ваших систем начнут испытывать проблемы с отказом EEPROM. (Посмотрите в даташит, чтобы узнать конкретную цифру. Если вы хотите выпустить большое число устройств, «наихудший случай», вероятно, более важен чем «типичный»). Миллион записей кажется большой цифрой, но на самом деле он закончится очень быстро. Давайте посмотрим на примере, предположив, что нам нужно сохранять измеренное напряжение в одну ячейку каждые 15 секунд. 1,000,000 записей при одной записи в 15 секунд дают записи в минуту: Ниже приведен график, показывающая время до износа (в годах), основанный на периоде обновления конкретной ячейки EEPROM. Ограничительная линия для продукта с продолжительностью жизни 10 лет составляет одно обновление каждые 5 минут 15 секунд для микросхемы с ресурсом 1 миллион записей. Для EEPROM с ресурсом 100К можно обновлять конкретную ячейку не чаще одного раза в 52 минуты. Это означает, что не стоит и надеяться обновлять ячейку каждые несколько секунд, если вы хотите, чтобы ваш продукт работал годы, а не месяцы. Вышесказанное масштабируется линейно, правда, в настоящем приборе имеются еще и вторичные факторы, такие как температура и режим доступа. Примечание: для тех, кто хотел бы узнать больше, Microchip подготовил документ, содержащий детальную информацию об устройстве ячеек EEPROM и их износе с диаграммами: Дайте мне знать, если у вас имеются какие-либо интересные идеи по поводу борьбы с износом EEPROM. Источик: Phil Koopman, «Better Embedded System SW» Примечание переводчика: в последние годы появились микросхемы EEPROM со страничной организацией стирания (подобной микросхемам FLASH), где логически можно адресовать ячейки (читать, записывать и стирать) побайтно, но при этом микросхема невидимо для пользователя стирает всю страницу целиком и перезаписывает новыми данными. Т.е. стерев ячейки по адресу 0, мы фактически стёрли и перезаписали ячейки с адресами 0...255 (при размере страницы 256 байт), поэтому трюк с буфером в этом случае не поможет. При исчерпании ресурс записей у такой микросхемы выходит из строя не одна ячейка, а вся страница целиком. В даташитах для таких микросхем ресурс записи указан для страницы
, а не для конкретной ячейки. Смотри, например, даташит на 25LC1024 от Microchip. Теги:
У микросхемы 8 ножек. Все, кроме питания и земли, отображены на скриншоте слева. С SCK и SDA мы знакомы, WP – Write Protect (защита от записи), A0:A2 используются для выбора переменной части адреса ведомой микросхемы (для чего нужны, уже писал где-то выше). Даташит на эту микросхему можете найти по запросу 24XX64 в гугле. Там можете проверить постоянную часть адреса и частоту, а также посмотреть, как использовать ножки WP, A0:A2.
$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 раз отправляем необходимые данные, причем если отправить 17 байт, то последний байт перезапишет первый и т.д. Для примера запишем первую страницу первого блока. Адрес первой ячейки
&h00
.
$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
&
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).
$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
"отправляем адрес ячейки
Сначала я хотел обмануть судьбу записывая структурку данных в разные места 1К памяти чипа по кругу. Упёрся в то, что указатель надо где-то хранить тоже, а данные достаточно случайные, чтобы использовать какой-то маркер для последовательного поиска.
Протокол i2c для FRAM сильно проще, чем для EEPROM. Память работает быстрее передачи данных по шине и можно лить хоть все 2К ардуининых мозгов за один раз. Польза от моего кода хоть в том, что нет лишнего разбиения на блоки по 32 байта или вообще побайтной передачи.
Кода же немножко совсем.
Так как на модуле, кроме чипа и разъёмов, практически ничего нет, уже хочу купить несколько микросхем. Нравятся.Как избежать износа EEPROM
Когда вы записываете данные, время летит быстро
EEPROM повсеместно используется для сохранения параметров настройки и журнала работы во встраиваемых системах. К примеру, вы можете хотеть функцию «черного ящика», для записи последних данных на момент аварии или потери питания. Я видел спецификации с требованием записывать подобные данные каждые несколько секунд.
1,000,000 / (4 * 60 минут/час * 24 часа/день) = 173.6 дней.
Другими словами, ваша EEPROM исчерпает резерв в миллион записей менее чем через 6 месяцев.Уменьшить частоту
Самый безболезненный способ решить проблему-это просто записывать данные реже. В некоторых случаях требования к системе это позволяют. Или можно записывать только при каких-либо больших изменениях. Однако, с записью, привязанной к событиям, помните о возможном сценарии, при котором значение будет постоянно колебаться, и вызовет поток событий, которые приведут к износу EEPROM.
(Будет неплохо, если вы сможете определить, сколько раз производилась запись в EEPROM. Но это потребует счётчика, который будет храниться в EEPROM… при этом проблема превращается проблему износа счётчика.)Прерывание по снижению уровня питания
В некоторых процессорах имеется прерывание по низкому уровню питания, которое можно использовать для записи одного последнего значения в EEPROM, в то время как система выключается по потере питания. В общем случае, вы храните интересующее значение в ОЗУ, и сохраняете его в EEPROM только при выключении питания. Или, возможно, вы записываете EEPROM время от времени, и записываете другую копию в EEPROM как часть процедуры выключения, чтобы убедиться, что самые последние данные запишутся.
Важно убедиться, что есть большой конденсатор по питанию, который будет поддерживать напряжение, достаточное для программирования EEPROM достаточно продолжительное время. Это может сработать, если вам нужно записать одно или два значения, но не большой блок данных. Осторожно, тут имеется большое пространство для ошибки!Кольцевой буфер
Классическое решение проблемы износа-использовать кольцевой буфер FIFO, содержащий N последних записей значения. Так-же понадобится сохранять указатель на конец буфера в EEPROM. Это уменьшает износ EEPROM на величину, пропорциональную числу копий в этом буфере. Например, если буфер проходит через 10 различных адресов для сохранения одного значения, каждая конкретная ячейка модифицируется в 10 раз реже, и ресурс записи возрастает в 10 раз. Вам также понадобится отдельный счётчик или отметка времени для каждой из 10 копий, чтобы можно было определить, которая из них последняя на момент выключения. Другими словами, понадобится два буфера, один для значения, и один для счетчика. (Если сохранять счетчик по одному и тому-же адресу, это приведёт к его износу, т.к. он должен увеличиваться при каждом цикле записи.) Недостаток этого метода в том, что нужно в 10 раз больше места чтобы получить в 10 раз большую продолжительность жизни. Можно проявить смекалку, и упаковать счетчик вместе с данными. Если вы записываете большое количество данных, добавление нескольких байт для счетчика - не такая уж большая проблема. Но в любом случае, понадобится много EEPROM.
Atmel приготовил аппноут, содержащий все кровавые подробности:
AVR-101: High Endurance EEPROM Storage: www.atmel.com/images/doc2526.pdf Особый случай для счётчика числа записей
Иногда нужно сохранить счётчик, а не сами значения. К примеру, вы можете хотеть знать число включений прибора, или время работы вашего устройства. Самое плохое в счётчиках, это то, что у них постоянно меняется младший значащий бит, изнашивая младшие ячейки EEPROM быстрее. Но и тут возможно применить некоторые трюки. В аппноуте от Microchip есть несколько умных идей, таких как использование кода Грея, чтобы только один бит из многобайтового счётчика менялся при изменении значения счетчика. Также они рекомендуют использовать корректирующие коды для компенсации износа. (Я не знаю, насколько эффективно будет применение таких кодов, т.к. это будет зависеть от того, насколько независимы будут ошибки в битах в байтах счётчика, используйте на свой страх и риск, прим. авт.). Смотри аппноут: ww1.microchip.com/downloads/en/AppNotes/01449A.pdf
ftp.microchip.com/tools/memory/total50/tutorial.html
betterembsw.blogspot.ru/2015/07/avoiding-eeprom-wearout.html
Добавить метки
