Главная
Вирусы
Библиотека Wire для Arduino для работы с шиной I2C. Теория I2C, EEPROM от Atmel Библиотека программная реализация i2c на avr

Библиотека Wire для Arduino для работы с шиной I2C. Теория I2C, EEPROM от Atmel Библиотека программная реализация i2c на avr

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

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

Эта книга задумана как продолжение бестселлера «Programming Arduino: Getting Started with Sketches». Несмотря на то что эта книга включает краткое повторение основ из книги «Programming Arduino», она познакомит читателя с более продвинутыми аспектами программирования плат Arduino.

На разных моделях Arduino интерфейс I2C подключается к разным контактам. Например, в модели Uno используются контакты A4 и A5 - линии SDA и SCL соответственно, а в модели Leonardo используются контакты D2 и D3. (Подробнее о линиях SDA и SCL рассказывается в следующем разделе.) На обеих моделях линии SDA и SCL выводятся также на колодку, находящуюся рядом с контактом AREF (рис. 7.3).

В табл. 7.1 перечисляются наиболее распространенные модели платы Arduino и контакты, соответствующие интерфейсу I2C.

Рис. 7.3. Контакты I2C на плате Arduino Uno

Таблица 7.1. Контакты I2C в разных моделях Arduino

Модель Контакты Примечания
Uno A4 (SDA) и A5 (SCL) Контакты подписаны SCL и SDA и находятся рядом с контактом AREF. Эти линии интерфейса выводятся также на контакты A4 и A5
Leonardo D2 (SDA) и D3 (SCL) Контакты подписаны SCL и SDA и находятся рядом с контактом AREF. Эти линии интерфейса выводятся также на контакты D2 и D3
Mega2560 D20 (SDA) и D21 (SCL) -
Due D20 (SDA) и D21 (SCL) Модель Due имеет вторую пару контактов I2C, подписанных SDA1 и SCL1

Протокол I2C

Для передачи и приема данных через интерфейс I2C используются две линии (отсюда второе название - двухпроводной интерфейс, Two Wire Interface). Эти две линии называют также тактовой линией (Serial Clock Line, SCL) и линией данных (Serial Data Line, SDA). На рис. 7.4 изображена временная диаграмма сигнала, передаваемого через интерфейс I2C.

Рис. 7.4. Временная диаграмма сигнала, передаваемого через интерфейс I2C

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

Библиотека Wire

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

Чтобы задействовать библиотеку Wire, ее сначала нужно подключить командой

#include

Инициализация I2C

В большинстве случаев плата Arduino играет роль ведущего устройства на любой шине I2C. Чтобы инициализировать Arduino как ведущее устройство, нужно выполнить команду begin в функции setup, как показано далее:

Обратите внимание: поскольку в данном случае плата Arduino действует как ведущее устройство, ей не нужно присваивать адрес. Если бы плата настраивалась на работу в режиме ведомого устройства, нам пришлось бы присвоить адрес в диапазоне от 0 до 127, передав его как параметр, чтобы уникально идентифицировать плату на шине I2C.

Отправка данных ведущим устройством

Чтобы отправить данные устройству на шине I2C, сначала нужно выполнить функцию beginTransmission и передать ей адрес устройства-получателя:

Wire.beginTransmission(4);

Отправка данных устройствам на шине I2C может производиться побайтно или целыми массивами типа char, как показано в следующих двух примерах:

Wire.send(123); // передача байта со значением 123

Wire.send("ABC"); // передача строки символов "ABC"

По окончании передачи должна вызываться функция endTransmission:

Wire.endTransmission();

Прием данных ведущим устройством

Чтобы принять данные от ведомого устройства, сначала нужно указать количество ожидаемых байтов вызовом функции requestFrom:

Wire.requestFrom(4, 6); // запросить 6 байт у устройства с адресом 4

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

#include

Wire.begin(); // подключиться к шине i2c (для ведущего

// устройства адрес не указывается)

Serial.begin(9600); // инициализировать монитор последовательного порта

Wire.requestFrom(8, 6); // запросить 6 байт у ведомого устройства #8

while (Wire.available()) { // ведомое устройство может прислать меньше

char c = Wire.read(); // принять байт как символ

Библиотека Wire автоматически буферизует входящие данные.

Примеры использования I2C

Любое устройство I2C должно иметь сопроводительное техническое описание, где перечисляются поддерживаемые им сообщения. Такие описания необходимы, чтобы конструировать сообщения для отправки ведомым устройствам и интерпретировать их ответы. Однако для многих устройств I2C, которые можно подключить к плате Arduino, существуют специализированные библиотеки, обертывающие сообщения I2C в простые и удобные функции. Фактически, если вам придется работать с каким-то устройством, для которого отсутствует специализированная библиотека, опубликуйте собственную библиотеку для всеобщего использования и заработайте себе несколько очков в карму.

Даже если полноценная библиотека поддержки того или иного устройства отсутствует, часто в Интернете можно найти полезные фрагменты кода, демонстрирующие работу с устройством.

УКВ-радиоприемник TEA5767

В первом примере, демонстрирующем взаимодействие с устройством I2C, библиотека не используется. Здесь осуществляется обмен фактическими сообщениями между Arduino и модулем TEA5767. Данный модуль можно купить в Интернете очень недорого, он легко подключается к плате Arduino и используется как УКВ-приемник, управляемый Arduino.

Самый сложный этап - подключение устройства. Контактные площадки очень маленькие и расположены очень близко друг к другу, поэтому многие предпочитают смастерить или купить адаптер для подключения к плате.

На рис. 7.5 изображена схема подключения модуля к Arduino.

Рис. 7.5. Подключение модуля TEA5767 к плате Arduino Uno через интерфейс I2C

Техническое описание модуля TEA5767 можно найти по адресу www.sparkfun.com/datasheets/Wireless/General/TEA5767.pdf . Описание содержит массу технической информации, но, если пробежать взглядом по документу, можно заметить раздел с подробным описанием сообщений, распознаваемых устройством. В документации указывается, что TEA5767 принимает сообщения длиной 5 байт. Далее приводится полностью работоспособный пример, выполняющий настройку частоты сразу после запуска. На практике же обычно требуется несколько иной механизм настройки, например на основе кнопок и жидкокристаллического дисплея.

// sketch_07_01_I2C_TEA5767

#include

setFrequency(93.0); // МГц

void setFrequency(float frequency)

byte frequencyH = frequencyB >> 8;

Wire.beginTransmission(0x60);

Wire.write(frequencyH);

Wire.write(frequencyL);

Wire.write(0xB0);

Wire.write(0x10);

Wire.write(0x00);

Wire.endTransmission();

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

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

unsigned int frequencyB = 4 * (frequency * 1000000 + 225000) / 32768;

byte frequencyH = frequencyB >> 8;

byte frequencyL = frequencyB & 0XFF;

Команда >> сдвигает биты вправо, то есть операция >> 8 сдвинет старшие 8 бит в сторону младших на 8 двоичных разрядов. Оператор & выполняет поразрядную операцию И (AND), которая в данном случае сбросит старшие 8 бит и оставит только младшие. Более полное обсуждение операций с битами вы найдете в главе 9.

Остальной код в функции setFrequency инициализирует передачу сообщения I2C ведомому устройству с адресом 0x60, который закреплен за приемником TEA5767. Затем осуществляется последовательная передача 5 байт, начиная с 2 байт частоты.

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

В приложении мы еще вернемся к этому примеру и создадим библиотеку для Arduino, чтобы упростить работу с модулем TEA5767.

Взаимодействие между двумя платами Arduino

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

Схема соединения плат для этого примера показана на рис. 7.6. Обратите внимание на то, что модуль TEA5767 имеет встроенные подтягивающие сопротивления на линиях I2C. Однако в данном случае, когда друг к другу подключаются две платы Arduinos, такие резисторы отсутствуют, поэтому понадобится включить свои сопротивления с номиналом 4,7 кОм (рис. 7.6).

Рис. 7.6. Соединение двух плат Arduino через интерфейс I2C

В платы должны быть загружены разные скетчи. Оба скетча включены в состав примеров для библиотеки Wire. Программа для ведущей платы Arduino находится в меню File->Example->Wire->master_writer (Файл-> Примеры->Wire->master_writer), а для ведомой платы - в меню File-> Example->Wire->slave_receiver (Файл->Примеры->Wire->slave_receiver).

Запрограммировав обе платы, оставьте ведомую подключенной к компьютеру, чтобы увидеть вывод с этой платы в монитор последовательного порта и обеспечить питание ведущей платы Arduino.

Начнем со скетча в ведущей плате:

#include

Wire.begin(); // подключиться к шине i2c (для ведущего устройства

// адрес не указывается)

Wire.beginTransmission(4); // инициализировать передачу устройству #4

Wire.write("x is "); // послать 5 байт

Wire.write(x); // послать 1 байт

Wire.endTransmission(); // остановить передачу

Этот скетч генерирует сообщение вида x is 1, где 1 - число, увеличивающееся каждые полсекунды. Затем сообщение посылается ведомому устройству с адресом 4, как определено в вызове beginTransmission.

Задача ведомого скетча - принять сообщение от ведущего устройства и вывести его в монитор последовательного порта:

#include

Wire.begin(4); // подключиться к шине i2c с адресом #4

Wire.onReceive(receiveEvent); // зарегистрировать обработчик события

Serial.begin(9600); // открыть монитор последовательного порта

// эта функция вызывается всякий раз, когда со стороны ведущего устройства

// поступают очередные данные, эта функция зарегистрирована как обработчик

// события, см. setup()

void receiveEvent(int howMany) {

while (1 < Wire.available()) { // цикл по всем принятым байтам, кроме

// последнего

Serial.print(c); // вывести символ

Serial.println(x); // вывести целое число

Первое, на что следует обратить внимание в этом скетче, - функции Wire.begin передается параметр 4. Он определяет адрес ведомого устройства на шине I2C, в данном случае 4. Он должен соответствовать адресу, который используется ведущим устройством для отправки сообщений.

СОВЕТ

К одной двухпроводной шине можно подключить множество ведомых плат Arduino при условии, что все они будут иметь разные адреса I2C.

Скетч для ведомой платы отличается от скетча для ведущей платы, потому что использует прерывания для приема сообщений, поступающих от ведущего устройства. Установка обработчика сообщений выполняется функцией onReceive, которая вызывается подобно подпрограммам обработки прерываний (глава 3). Вызов этой функции нужно поместить в функцию setup, чтобы обеспечить вызов пользовательской функции receiveEvent при получении любых поступающих сообщений.

Функция receiveEvent принимает единственный параметр - количество байт, готовых для чтения. В данном случае это число игнорируется. Цикл while читает по очереди все доступные символы и выводит их в монитор последовательного порта. Затем выполняются чтение единственного однобайтного числа в конце сообщения и его вывод в монитор порта. Использование println вместо write гарантирует, что значение байта будет выведено как число, а не символ с соответствующим числовым кодом (рис. 7.7).

Рис. 7.7. Вывод в монитор порта сообщений, получаемых одной платой Arduino от другой через интерфейс I2C

Платы со светодиодными индикаторами

Еще один широкий спектр устройств I2C - разного рода дисплеи. Наиболее типичными представителями этих устройств являются светодиодные матрицы и семисегментные индикаторы, производимые компанией Adafruit. Они содержат светодиодные дисплеи, смонтированные на печатной плате, и управляющие микросхемы с поддержкой интерфейса I2C. Такое решение избавляет от необходимости использовать большое число контактов ввода/вывода на плате Arduino для управления светодиодным дисплеем и позволяет обойтись всего двумя контактами, SDA и SCL.

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

#include

#include "Adafruit_LEDBackpack.h"

#include "Adafruit_GFX.h"

Adafruit_8x8matrix matrix = Adafruit_8x8matrix();

matrix.begin(0x70);

matrix.drawLine(0, 0, 7, 7, LED_RED);

matrix.writeDisplay();

Часы реального времени DS1307

Еще одно распространенное устройство I2C - модуль часов реального времени DS1307. Для этого модуля также имеется удобная и надежная библиотека, упрощающая взаимодействие с модулем и избавляющая от необходимости иметь дело с фактическими сообщениями I2C. Библиотека называется RTClib и доступна по адресу https://github.com/adafruit/RTClib .

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

#include

#include "RTClib.h"

Serial.begin(9600);

if (! RTC.isrunning()) {

Serial.println("RTC is NOT running!");

// записать в модуль дату и время компиляции скетча

RTC.adjust(DateTime(__DATE__, __TIME__));

DateTime now = RTC.now();

Serial.print(now.year(), DEC);

Serial.print("/");

Serial.print(now.month(), DEC);

Serial.print("/");

Serial.print(now.day(), DEC);

Serial.print(" (");

Serial.print(daysOfTheWeek);

Serial.print(") ");

Serial.print(now.hour(), DEC);

Serial.print(":");

Serial.print(now.minute(), DEC);

Serial.print(":");

Serial.print(now.second(), DEC);

Serial.println();

Если вам интересно увидеть, как в действительности выполняются взаимодействия через интерфейс I2C, просто загляните в файлы библиотеки. Например, исходный код библиотеки RTClib хранится в файлах RTClib.h и RTClib.cpp. Эти файлы находятся в папке libraries/RTClib.

Например, в файле RTClib.cpp можно найти определение функции now:

DateTime RTC_DS1307::now() {

Wire.beginTransmission(DS1307_ADDRESS);

Wire.endTransmission();

Wire.requestFrom(DS1307_ADDRESS, 7);

uint8_t ss = bcd2bin(Wire.read() & 0x7F);

uint8_t mm = bcd2bin(Wire.read());

uint8_t hh = bcd2bin(Wire.read());

uint8_t d = bcd2bin(Wire.read());

uint8_t m = bcd2bin(Wire.read());

uint16_t y = bcd2bin(Wire.read()) + 2000;

return DateTime (y, m, d, hh, mm, ss);

Функция Wire.read возвращает значения в двоично-десятичном формате (Binary-Coded Decimal, BCD), поэтому они преобразуются в байты с помощью библиотечной функции bcd2bin.

В формате BCD байт делится на два 4-битных полубайта. Каждый полубайт представляет одну цифру двузначного десятичного числа. Так, число 37 в формате BCD будет представлено как 0011 0111. Первые четыре бита соответствуют десятичному значению 3, а вторые четыре бита - значению 7.

В заключение

В этой главе вы познакомились с интерфейсом I2C и приемами его использования для организации взаимодействий плат Arduino с периферийными устройствами и другими платами Arduino.

В следующей главе мы исследуем еще одну разновидность последовательного интерфейса, используемого для взаимодействий с периферией. Он называется 1-Wire . Этот интерфейс не получил такого широкого распространения, как I2C, но он используется в популярном датчике температуры DS18B20.

Пришла мне посылка из Китая в которой лежит микросхема EEPROM фирмы Atmel. Которую хочется подключить к Arduino. Но совершенно не хочется использовать готовую библиотека, а разобраться самому. По этому статья получиться немного объемной и скучной и разделем ее на три части:

  • Теория интерфейса I2C.
  • EEPROM, описания моей микросхемы(AT24C256) и подключение.
  • Написание библиотеки для работы с памятью.

Часть первая, I2C и библиотека «Wire».

Последовательный протокол обмена данными IIC (также называемый I2C — Inter-Integrated Circuits, межмикросхемное соединение). Разработана фирмой Philips Semiconductors в начале 1980-х как простая 8-битная шина внутренней связи для создания управляющей электроники. Так как право на использование его стоит денег фарма Atmel назвала его TWI , но смысл от этого не меняется.

Как это работает?

Для передачи данных используются две двунаправленные лини передачи данных. SDA (Serial Data) шина последовательных данных и SCL (Serial Clock) шина тактирования. Обе шины подтянуты резисторами к плюсовой шине питания. Передача/Прием сигналов осуществляется прижиманием линии в 0, в единичку устанавливается сама, за счет подтягивающих резисторов .

В сети есть хотя бы одно ведущее устройство (Master ), которое инициализирует передачу данных и генерирует сигналы синхронизации и ведомые устройства (Slave ), которые передают данные по запросу ведущего. У каждого ведомого устройства есть уникальный адрес, по которому ведущий и обращается к нему. Конечно понятно что Ведущий это наш микроконтроллер, а ведомый наша память. Ведущее устройство начинает прижимать шину SCL к нулю с определенной чистотой, а шину SDA прижимать или отпускать на определенное число тактов передавая Единичку или Нолик. Передача данных начинается с сигнала START потом передается 8 бит данных и 9-тым битом Ведомое устройство подтверждает прием байт прижимая шину SDA к минусу. Заканчивается передача сигналом STOP .

Библиотека «Wire».

Для облегчения обмена данными с устройствами по шине I2C для Arduino написана стандартная библиотека Wire которая есть уже в комплекте IDE . Она имеет следующие основные функции:

Wire.begin(Address) вызывается один раз для инициализации и подключения к шини как Ведущий или Ведомое устройство. Если Address не задан подключаемся как Мастер устройство.

Wire.beginTransmission(address) начинает передачу на ведомое I2C устройство с заданным адресом.

Wire.endTransmission() прекращает передачу данных ведомому. Функция возвращает значение типа byte :

  • 0 — успех.
  • 1- данные слишком длинны для заполнения буфера передачи.
  • 2 — принят NACK при передаче адреса.
  • 3 — принят NACK при передаче данных.
  • 4 — остальные ошибки.

Wire.write() запись данных от ведомого устройства в отклик на запрос от ведущего устройства, или ставит в очередь байты для передачи от мастера к ведомому устройству.Фактически записывает данные в буфер. Размер буфера 32 байт а (минус 2 байта адрес, фактически 30 байт ), а передает буфер функция Wire.endTransmission().

  • Wire.write(value) — value : значение для передачи, один байт.
  • Wire.write(string) — string : строка для передачи, последовательность байтов.
  • Wire.write(data, length) — data : массив данных для передачи, байты. length : количество байтов для передачи.

Wire.read() Считывает байт, который был передан от ведомого устройства к ведущему или который был передан от ведущего устройства к ведомому. Возвращаемое значение byte : очередной принятый байт.

Это самые основные функции библиотеке, остальные мы рассмотрим по ходу пьесы))

Часть вторая, EEPROM.

EEPROM (англ. Electrically Erasable Programmable Read-Only Memory ) - электрически стираемое перепрограммируемое ПЗУ (ЭСППЗУ), один из видов энергонезависимой памяти (таких, как PROM и EPROM). Память такого типа может стираться и заполняться данными до миллиона раз.

Мне прислали уже готовый модуль EEPROM с микросхемой AT24C256 фирмы Atmel объемом 32 кбайт. Что бы разобраться с этим чудом нам придется проштудировать datasheet который очень скучный и на английском. Так что я вам выдам уже готовый результат моих мук.

Характеристики:

  • Низковольтные и стандартные питание. VCC = 1.7V to 5.5V.
  • 400kHz (1.7V) and 1MHz (2.5V, 2.7V, 5.0V) совместим с частотой синхронизации.
  • Выносливость: 1,000,000 Циклов Записи.
  • Внутренне организованный как 32 768 страниц x 8 бит.

выводы:

  • WP — защита от записи. Если вывод подключен к GND то можно записывать данные в память.
  • A0…A2 — выводы задающие адрес устройства.
  • Vcc — питание плюс.
  • GND — питание минус.
Адрес памяти:

Задается тремя ногами A0..A2. Если нога прижата к Gnd то значение бита 0, если к Vcc то 1. Микросхема использует восьми битный адрес, последний бит отвечает за выбор операции . Если значение бита высокий то инициализируется операция чтения, если низкий(ноль) то операция записи.

То есть если все три вывода прижаты к GND и мы хотим записать в память, адрес устройства будет выглядеть как 10100000 (в библиотеке «Wire» используется 7-ми битный адрес, сдвигаем все в право на один бит 01010000 0x50 ).

Запись данных в память:

Для записи мы с начало обращаемся к памяти с битом Записи в адресе . Потом посылаем два 8-ми битных адреса(то есть у нас 0x8000 адресов) , затем байт данных и сигнал STOP . После этого EEPROM входит во внутренне синхронизированный цикл записи tWR(Write Cycle Time 5 ms) в энергонезависимую память. Все входные сигналы
отключено во время этого цикла записи, и EEPROM не ответит, пока запись не будет завершена .

Копаемся дальше и находим в datasheet что память микросхемы организована как 512 страниц по 64 байта . То есть мы может записать сразу до 64 байт информации за одну команду. Для этого мы передаем все 64 байта информации и только после этого посылаем сигнал STOP .

Чтение данных:

С чтением данных все интересней. Память поддерживает три варианта чтения:

  • Читать текущий адрес;
  • Читать случайный адрес;
  • Последовательное чтение;

Память запоминает последний адрес записи пока не отключено питание, по этому мы можем прочитать последний байт без указания адреса.

Что бы прочитать случайный адрес нам нужно с начало отправить команду на запись и передать адрес который хотим прочитать(не забывайте что адрес состоит из двух 8-ми битных частей ). За тем отправить команду на чтение и получить искомый байт, завершив все командой STOP.

Последовательное чтение может выполняться как с текущего адреса так и со случайного и будет продолжаться пока микроконтроллер не отправит сигнал СТОП. При переполнении адреса память ее сбросить и адресация начнется с начала.

Ну что же пришло время попробовать что нибудь записать:
#include // Подключаем библиотеку #define EEPROM_ADDRESS 0x53 // Задаем адрес памяти word address = 0; // Адрес куда будем записывать byte data_send = 170 ; // Даные void setup() { Wire.begin(); // Инициализируем I2C Serial.begin(9600); Serial.print("Write byte to EEPROM memory..."); Serial.println (data_send); Wire.beginTransmission(EEPROM_ADDRESS); // Начинаем передачу Wire.write(address >> 8); Wire.write(address & 0xFF); // Отправляем два байта адреса Wire.write(data_send); // Отправляем данные byte status= Wire.endTransmission(); // Заканчиваем передачу и проверяем статус передачи. if (status == 0)Serial.println ("Ок"); // delay(10); Serial.println("Read byte from EEPROM memory..."); Wire.beginTransmission(EEPROM_ADDRESS); // Что бы прочитать данные отравляем сначала адрес где они лежат. Wire.write(address >> 8); Wire.write(address & 0xFF); status= Wire.endTransmission(); if (status == 0)Serial.println ("Ок"); // stop transmitting Wire.requestFrom(EEPROM_ADDRESS, (byte)1); // отправляем команду на чтение одного байта данных byte data = 0; if (Wire.available()) // проверяем что есть данные для чтения. { data = Wire.read(); //читаем данные } Serial.println (data, DEC); } void loop() { }

Wire.requestFrom(address, quantity) — Используется мастером для запроса байтов от ведомого устройства. Эти байты могут быть получены с помощью методов available() и read() . Размер буфера такой же 32 байта .

  • address : 7-битный адрес устройства, у которого запрашиваются байты;
  • quantity : количество запрашиваемых байтов;

Wire.available() — Возвращает количество байтов, доступных для получения с помощью read() .

Ну и пример с записью в память строки «Hello Word»:

#include #define EEPROM_ADDRESS 0x53 word address = 0; char data_send = "Hello Word" ; void setup() { Wire.begin(); // Serial.begin(9600); Serial.print("Write byte to EEPROM memory..."); Serial.println (data_send); Wire.beginTransmission(EEPROM_ADDRESS); Wire.write(address >> 8); Wire.write(address & 0xFF); Wire.write(data_send); byte status= Wire.endTransmission(); if (status == 0)Serial.println ("Ок"); delay(10); Serial.println("Read byte from EEPROM memory..."); Wire.beginTransmission(EEPROM_ADDRESS); Wire.write(address >> 8); Wire.write(address & 0xFF); status= Wire.endTransmission(); if (status == 0)Serial.println ("Ок"); // stop transmitting Wire.requestFrom(EEPROM_ADDRESS, (byte)10); byte data = 0; for (int i=0 ; i<10 ;i++) { if (Wire.available()) { data = Wire.read(); } Serial.write (data); } } void loop() { }

Организация памяти:

Так как в datasheet об этом написано смутно. Я на практике пытался разобраться с этим. В datasheet написано что память микросхемы организована как 512 страниц по 64 байта . Что это значит? Если мы захотим записать больше 64 байт сразу,скажем по адресу 0x40(адрес начало второй страницы), при выходе адреса за границы страницы внутренний счетчик микросхемы сбросит адрес на начало страницы . А лишние байты будут записаны в начало страницы и сотрут данные которые были там записаны.

Для чтения таких ограничений нету, в даташипе написано только то что когда вы достигнете конца адресов вас автоматически перекинет на начало (адрес 0х00).

На этом я думаю все. Вы конечно можете скачать уже готовую библиотеку для EEPROM , дума сможете и написать свою. Главное мы разобрались в основном принципе работы.

С номиналами от 10 Ом до 1 МОм);

  • 2 резистора по 4,7 кОм (из того же набора);
  • соединительные провода (например, вот хороший набор);
  • компьютер с Arduino IDE.

    • 1 Описание интерфейса I2C

    Последовательный протокол обмена данными IIC (также называемый I2C - Inter-Integrated Circuits, межмикросхемное соединение) использует для передачи данных две двунаправленные линии связи, которые называются шина последовательных данных SDA (Serial Data) и шина тактирования SCL (Serial Clock) . Также имеются две линии для питания. Шины SDA и SCL подтягиваются к шине питания через резисторы.

    В сети есть хотя бы одно ведущее устройство (Master) , которое инициализирует передачу данных и генерирует сигналы синхронизации. В сети также есть ведомые устройства (Slave) , которые передают данные по запросу ведущего. У каждого ведомого устройства есть уникальный адрес, по которому ведущий и обращается к нему. Адрес устройства указывается в паспорте (datasheet). К одной шине I2C может быть подключено до 127 устройств, в том числе несколько ведущих. К шине можно подключать устройства в процессе работы, т.е. она поддерживает «горячее подключение».

    Давайте рассмотрим временную диаграмму обмена по протоколу I2C. Есть несколько различающихся вариантов, рассмотрим один из распространённых. Воспользуемся логическим анализатором, подключённым к шинам SCL и SDA.

    Мастер инициирует обмен. Для этого он начинает генерировать тактовые импульсы и посылает их по линии SCL пачкой из 9-ти штук. Одновременно на линии данных SDA он выставляет адрес устройства , с которым необходимо установить связь, которые тактируются первыми 7-ми тактовыми импульсами (отсюда ограничение на диапазон адресов: 2 7 = 128 минус нулевой адрес). Следующий бит посылки - это код операции (чтение или запись) и ещё один бит - бит подтверждения (ACK), что ведомое устройство приняло запрос. Если бит подтверждения не пришёл, на этом обмен заканчивается. Или мастер продолжает посылать повторные запросы.

    Это проиллюстрировано на рисунке ниже.. В первом случае, для примера, отключим ведомое устройство от шины. Видно, что мастер пытается установить связь с устройством с адресом 0x27, но не получает подтверждения (NAK). Обмен заканчивается.


    Теперь подключим к шине I2C ведомое устройство и повторим операцию. Ситуация изменилась. На первый пакет с адресом пришло подтверждение (ACK) от ведомого. Обмен продолжился. Информация передаётся также 9-битовыми посылками, но теперь 8 битов занимают данные и 1 бит - бит подтверждения получения ведомым каждого байта данных. Если в какой-то момент связь оборвётся и бит подтверждения не придёт, мастер прекратит передачу.

    2 Реализация I2C в Arduino

    Arduino использует для работы по интерфейсу I2C два порта. Например, в Arduino UNO и Arduino Nano аналоговый порт A4 соответствует SDA, аналоговый порт A5 соответствует SCL.


    Для других моделей плат соответствие выводов такое:

    3 Библиотека "Wire" для работы с IIC

    Для облегчения обмена данными с устройствами по шине I2C для Arduino написана стандартная библиотека Wire . Она имеет следующие функции:

    Функция Назначение
    begin(address) инициализация библиотеки и подключение к шине I2C; если не указан адрес, то присоединённое устройство считается ведущим; используется 7-битная адресация;
    requestFrom() используется ведущим устройством для запроса определённого количества байтов от ведомого;
    beginTransmission(address) начало передачи данных к ведомому устройству по определённому адресу;
    endTransmission() прекращение передачи данных ведомому;
    write() запись данных от ведомого в ответ на запрос;
    available() возвращает количество байт информации, доступных для приёма от ведомого;
    read() чтение байта, переданного от ведомого ведущему или от ведущего ведомому;
    onReceive() указывает на функцию, которая должна быть вызвана, когда ведомое устройство получит передачу от ведущего;
    onRequest() указывает на функцию, которая должна быть вызвана, когда ведущее устройство получит передачу от ведомого.

    4 Подключение I2C устройства к Arduino

    Давайте посмотрим, как работать с шиной I2C с помощью Arduino.

    Сначала соберём схему, как на рисунке. Будем управлять яркостью светодиода, используя цифровой 64-позиционный потенциометр AD5171 (см. техническое описание), который подключается к шине I2C. Адрес, по которому мы будем обращаться к потенциометру - 0x2c (44 в десятичной системе).


    5 Управление устройством по шине IIC

    Рассмотрим диаграммы информационного обмена с цифровым потенциометром AD5171, представленные в техническом описании:


    Нас тут интересует диаграмма записи данных в регистр RDAC . Этот регистр используется для управления сопротивлением потенциометра.

    Откроем из примеров библиотеки "Wire" скетч: Файл Образцы Wire digital_potentiometer . Загрузим его в память Arduino.

    #include // подключаем библиотеку "Wire" byte val = 0; // значение для передачи потенциометру void setup() { Wire.begin(); // подключаемся к шине I2C как мастер } void loop() { Wire.beginTransmission(44); // начинаем обмен с устройством с I2C адресом "44" (0x2C) Wire.write(byte(0x00)); // посылаем инструкцию записи в регистр RDAC Wire.write(val); // задаём положение 64-позиционного потенциометра Wire.endTransmission(); // завершаем I2C передачу val++; // инкрементируем val на 1 if (val == 63) { // по достижении максимума потенциометра val = 0; // сбрасываем val } delay(500); }

    После включения вы видите, как яркость светодиода циклически нарастает, а потом гаснет. При этом мы управляем потенциометром с помощью Arduino по шине I2C.

    Why another I2C library?

    The standard I2C library for the Arduino is the Wire library . While this library is sufficient most of the time, there are situations when it cannot be used:

    • the I2C pins A4/A5 (or SDA/SCL) are in use already for other purposes,
    • the code shall run on both an ATmega processor with 16 MHz and an ATtiny processor with 1 MHz ,
    • you are short on memory (flash and RAM).

    Features

    • compatible with all 8-bit AVR MCUs
    • can make use of almost any pin
    • clock stretching (by slaves) supported
    • timeout on clock stretching
    • timeout on ACK polling for busy devices (new!)
    • internal MCU pullup resistors can be used (new!)
    • very lightweight (roughly 250 bytes of flash and 0 byte of RAM, except for call stack)
    • very fast (standard and fast mode on UNO, 33 kHz with 1 MHz CPU clock)
    • Optional Wire library compatible interface
    • no bus arbitration (i.e., only one master allowed on bus)
    • supports only master mode
    • GPL license

    Using the library

    Alternative Interface

    Meanwhile, I have written a wrapper around SoftI2CMaster that emulates the Wire library (master mode only). It is another C++-header file called SoftWire .h which you need to include instead of SoftI2CMaster .h . Directly after this include statement you need to create a Wire instance.

    This interface sacrifices some of the advantages of the original library, in particular its small footprint, but comes handy if you need a replacement of the original Wire library. The following table lists the memory requirements.

    WireSoftI2CMaster SoftWire Flash memory RAM
    1956 252 712 208 0 64

    Описание библиотеки Wire

    Данная библиотека позволяет вам взаимодействовать с I2C / TWI устройствами. На платах Arduino с компоновкой R3 (распиновка 1.0) SDA (линия данных) и SCL (линия тактового сигнала) находятся на выводах около вывода AREF. Arduino Due имеет два I2C / TWI интерфейса: SDA1 и SCL1 находятся около вывода AREF, а дополнительные линии находятся на выводах 20 и 21.

    В таблице ниже показано, где расположены TWI выводы на разных платах Arduino.

    Начиная с Arduino 1.0, данная библиотека наследует функции Stream , что делает ее совместимой с другими библиотеками чтения/записи. Из-за этого send() и receive() были заменены на read() и write() .

    Примечание

    Существуют 7- и 8-битные версии адресов I2C. 7 битов идентифицируют устройство, а восьмой бит определяет, идет запись или чтение. Библиотека Wire использует 7 битные адреса. Если у вас есть техническое описание или пример кода, где используется 8-битный адрес, вам нужно откинуть младший бит (т.е. сдвинуть значение на один бит вправо), получив адрес от 0 до 127. Однако адреса от 0 до 7 не используются, так как зарезервированы, поэтому первым адресом, который может быть использован, является 8. Обратите внимание, что при подключении выводов SDA/SCL необходимы подтягивающие резисторы. Для более подробной информации смотрите примеры. На плате MEGA 2560 есть подтягивающие резисторы на выводах 20 и 21.

    Описание методов

    Wire.begin()

    Описание

    Инициализирует библиотеку Wire и подключается к шине I2C как ведущий (мастер) или ведомый. Как правило, должен вызываться только один раз.

    Синтаксис

    Wire.begin(address)

    Параметры

    address: 7-битный адрес ведомого устройства (необязательно); если не задан, плата подключается к шине как мастер.

    Возвращаемое значение

    Пример

    Примеры для ведомого устройства смотрите в примерах к методам onReceive() и onRequest() . Примеры для ведущего устройства смотрите в примерах к остальным методам. .

    Wire.requestFrom()

    Описание

    Используется мастером для запроса байтов от ведомого устройства. Эти байты могут быть получены с помощью методов available() и read() .

    Если этот аргумент равен true , то requestFrom() после запроса посылает сообщение STOP, освобождая шину I2C.

    Если этот аргумент равен false , то requestFrom() после запроса посылает сообщение RESTART. Шина не освобождается, что мешает другому устройству-мастеру влезть между сообщениями. Это позволяет одному ведущему устройству посылать несколько запросов, пока оно контролирует шину.

    Синтаксис

    Wire.requestFrom(address, quantity)

    Wire.requestFrom(address, quantity, stop)

    Параметры

    • address: 7-битный адрес устройства, у которого запрашиваются байты;
    • quantity: количество запрашиваемых байтов;
    • stop: boolean . true посылает сообщение STOP после запроса. false посылает сообщение RESTART после запроса, сохраняя соединение активным.
    Возвращаемое значение

    byte: количество байтов, возвращенных от ведомого устройства.

    Пример

    Wire.beginTransmission()

    Описание

    Начинает передачу на ведомое I2C устройство с заданным адресом. После него последовательность байтов для передачи ставится в очередь с помощью функции write() , и их передача с помощью вызова endTransmission() .

    Синтаксис

    Wire.beginTransmission(address)

    Параметры

    address: 7-битный адрес устройства, на которое необходимо передать данные.

    Возвращаемое значение

    Пример

    Wire.endTransmission()

    Описание

    Завершает передачу на ведомое устройство, которая была начата методом beginTransmission() и передает байты, которые были поставлены в очередь методом write() .

    Для совместимости с определенными I2C устройствами, начиная с Arduino 1.0.1, requestFrom() принимает аргумент логического типа данных, меняющий его поведение.

    Если этот аргумент равен true , то requestFrom() после передачи посылает сообщение STOP, освобождая шину I2C.

    Если этот аргумент равен false , то requestFrom() после передачи посылает сообщение RESTART. Шина не освобождается, что мешает другому устройству-мастеру влезть между сообщениями. Это позволяет одному ведущему устройству посылать несколько передач, пока оно контролирует шину.

    По умолчанию этот аргумент равен true .

    Синтаксис

    Wire.endTransmission()

    Wire.endTransmission(stop)

    Параметры

    stop: boolean . true посылает сообщение STOP после передачи. false посылает сообщение RESTART после передачи, сохраняя соединение активным.

    Возвращаемое значение

    byte , который указывает на состояние передачи:

    • 0: успех;
    • 1: данные слишком длинны для заполнения буфера передачи;
    • 2: принят NACK при передаче адреса;
    • 3: принят NACK при передаче данных;
    • 4: остальные ошибки.
    Пример

    Смотрите пример к методу write() .

    Wire.write()

    Описание

    Записывает данные от ведомого устройства в отклик на запрос от ведущего устройства, или ставит в очередь байты для передачи от мастера к ведомому устройству (между вызовами beginTransmission() и endTransmission()).

    Синтаксис

    Wire.write(value)

    Wire.write(string)

    Wire.write(data, length)

    Параметры

    • value: значение для передачи, один байт.
    • string: строка для передачи, последовательность байтов.
    • data: массив данных для передачи, байты.
    • length: количество байтов для передачи.
    Возвращаемое значение

    byte: write() возвращает количество записанных байтов, хотя чтение этого количества не обязательно.

    Пример #include byte val = 0; void setup() { Wire.begin(); // подключиться к шине i2c } void loop() { Wire.beginTransmission(44); // передача на устройство #44 (0x2c) // адрес устройства задан в техническом описании Wire.write(val); // отправить байт значения Wire.endTransmission(); // остановить передачу val++; // увеличить значение if(val == 64) // если дошли до 64-го значения (max) { val = 0; // начать с начала } delay(500); }

    Wire.available()

    Описание

    Возвращает количество байтов, доступных для получения с помощью read() . Этот метод должен вызываться на ведущем устройстве после вызова requestFrom() или на ведомом устройстве внутри обработчика onReceive() .

    Синтаксис

    Wire.available()

    Параметры

    Возвращаемое значение

    Количество байтов, доступных для чтения.

    Пример

    Смотрите пример к методу read() .

    Wire.read()

    Описание

    Считывает байт, который был передан от ведомого устройства к ведущему после вызова requestFrom() , или который был передан от ведущего устройства к ведомому.

    Синтаксис

    Параметры

    Возвращаемое значение

    byte: очередной принятый байт.

    Пример #include byte val = 0; void setup() { Wire.begin(); // подключиться к шине i2c (адрес для мастера не обязателен) Serial.begin(9600); // настроить последовательный порт для вывода } void loop() { Wire.requestFrom(2, 6); // запросить 6 байтов от ведомого устройства #2 while(Wire.available()) // ведомое устройство может послать меньше, чем запрошено { char c = Wire.read(); // принять байт как символ Serial.print(c); // напечатать символ } delay(500); }

    Wire.setClock()

    Описание

    Изменяет тактовую частоту для связи по шине I2C. У ведомых I2C устройств нет минимальной рабочей тактовой частоты, однако обычно используется 100 кГц.

    Синтаксис

    Wire.setClock(clockFrequency)

    Параметры

    clockFrequency: значение частоты (в герцах) тактового сигнала. Принимаются значения 100000 (стандартный режим) и 400000 (быстрый режим). Некоторые процессоры также поддерживают 10000 (низкоскоростной режим), 1000000 (быстрый режим плюс) и 3400000 (высокоскоростной режим). Чтобы убедиться, что необходимый режим поддерживается, обращайтесь к технической документации на конкретный процессор.

    Возвращаемое значение

    Wire.onReceive()

    Описание

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

    Синтаксис

    Wire.onReceive(handler)

    Параметры

    handler: функция, которая должна будет вызываться, когда ведомое устройство принимает данные; она должна принимать один параметр int (количество байтов, прочитанных от мастера) и ничего не возвращать, т.е.:

    void myHandler(int numBytes)

    Возвращаемое значение

    Пример

    #include void setup() { Wire.begin(8); // подключиться к i2c шине с адресом #8 Wire.onReceive(receiveEvent); // зарегистрировать обработчик события Serial.begin(9600); // настроить последовательный порт для вывода } void loop() { delay(100); } // функция, которая будет выполняться всякий раз, когда от мастера принимаются данные // данная функция регистрируется как обработчик события, смотрите setup() void receiveEvent(int howMany) { while (1 < Wire.available()) // пройтись по всем до последнего { char c = Wire.read(); // принять байт как символ Serial.print(c); // напечатать символ } int x = Wire.read(); // принять байт как целое число Serial.println(x); // напечатать число }

    Wire.onRequest()

    Описание

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

    Синтаксис

    Wire.onRequest(handler)

    Параметры

    handler: функция, которая должна будет вызываться, она не принимает параметров и ничего не возвращает, т.е.:

    void myHandler()

    Возвращаемое значение

    Пример

    Код для платы Arduino, работающей в качестве ведомого устройства:

    #include void setup() { Wire.begin(8); // подключиться к i2c шине с адресом #8 Wire.onRequest(requestEvent); // зарегистрировать обработчик события } void loop() { delay(100); } // функция, которая будет выполняться всякий раз, когда мастером будут // запрошены данные // данная функция регистрируется как обработчик события, смотрите setup() void requestEvent() { Wire.write("hello "); // ответить сообщением }

    Разделы