Интерфейс передачи данных - I2C

Модули 1 января 2024

Содержание

Назначение и принцип работы,
Реализация в Ардуино,
Примеры,
Вывод,
FAQ.

Назначение и принцип работы

Стандарт довольно древний, придуман инженерами Philips более 30 лет назад, а потому - в разных модификациях и под разными названиями - очень широко распространен в электронных устройствах различного назначения. Пожалуй, второй по популярности интерфейс в Ардуино среде после UART, где чаще всего используется для обмена данными между контроллером, датчиками и исполнительными устройствами.

Обязательно к прочтению: Интерфейс передачи данных UART

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

В отличие от UART, i2c является протоколом синхронной связи, это означает, что обмен данными происходит по общему для всех связанных устройств сигналу синхронизации. Генерацией сигнала занимается только единое главное устройство, оно же Ведущее, оно же Master по-английски. Устройство “говорит” и “дает слово” остальным, которые называются Ведомыми, по-английски Slave. Все ведомые устройства имеют уникальный номер, даже если такое устройство на всю сеть одно. Мастер номера не имеет, его и так все знают. Ведомые молчат, слушают, что говорит ведущий и откликаются только тогда, когда ведущий их об этом просит, называя их по имени (номеру), поэтому в сети всегда царит образцовый порядок.

Разберемся в общих чертах, как работает протокол i2c, это поможет правильно пользоваться им, понимая, что и в каком порядке происходит в недрах устройств. Обращение мастера начинается с падения уровня на шине данных SDA, что является стартовым сигналом для ведомых. Повышение уровня SDA при высоком тактовой сигнале является для них стоп-командой. Все, что происходит между этими событиями, называется “сообщение”, то есть передача данных.

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

Что такое “старт” и “стоп” понятно. Адрес 7-10 бит, в зависимости от разновидности протокола, тот самый идентификатор конкретного ведомого устройства, к которому обращается ведущий. Далее бит чтения или записи, объясняющий что мы хотим - передать данные или получить их. ACK/NACK - биты подтверждения или неподтверждения приема информации каждого кадра. Да, ACK единственный бит, который генерируется в линии SCL ведомым устройством. К сожалению, без дополнительных мер мы не можем воспользоваться этой информацией о доставке, она лишь сокращает время передачи, обрывая ее, когда принимающее устройство перестает отвечать.

Интерфейс i2c предназначен для довольно быстрой и надежной передачи на небольшие расстояния, обычно в пределах одного устройства. Как правильно, длина проводов ограничена несколькими метрами. Он занимает, своего рода, промежуточное положение между UART и SPI по параметрам скорости, надежности, расстоянию и использованию ресурсов.

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

На каждой плате Ардуино имеется пины, на аппаратном уровне поддерживающие интерфейс i2c. Для UNO, Nano, Pro Mini это A4 - SDA, A5 - SCL. У Меги SDA находится на пине 20, SCL на пине 21.

Для удобной работы с интерфейсов в среде Ардуино имеется стандартная библиотека Wire, создающая одноименный класс. Рассмотрим некоторые его функции.

Общие:

.begin(address) - запуск класса, подключение к шине. Если адрес не указан, значит мы на мастере, если указан, значит это адрес ведомого.

.write() - передача байта или последовательности байт, в зависимости от параметров.

.read() - возвращает очередной принятый байт.

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

Функции только для ведущего устройства (мастера):

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

.endTransmission() - прекращение передачи данных ведомому устройству.

Далее две функции только для ведомого устройства:

.onReceive(foo) - в качестве параметра указывается функция, вызываемая при получении данных от ведущего.

.onRequest(foo) - в качестве параметра указывается функция, которая вызывается когда требуется отправить данные на ведущий.

Как видно из одного списка функций, работа протокола на ведущем и работа на ведомом устройстве сильно различаются. У ведущего все действия совершаются директивным образом, команда подается тогда, когда это нужно. У ведомого прием и отправка осуществляются автоматически по факту обращения от ведущего. Для приема требуется написать функцию, реагирующую на команды, для отправки необходимо всегда иметь заранее готовые данные. Ведущее устройство никогда не может отправить информацию по собственной инициативе, если мастеру требуется постоянно быть в курсе событий, он вынужден будет регулярно “пинать” соответствующее устройство для получения новых данных. В такой организации, бесспорно, есть свои плюсы и минусы.

Посмотрим, как это происходит на практике.

Примеры

Как говорилось выше, чаще всего протокол i2c используется для общения контроллера (в качестве мастера) с датчиками и исполнительными устройствами. Это удобно, когда требуется высокая скорость и надежность обмена данными. Например, индикаторы, дисплеи, часы реального времени, датчики температуры, влажности и других параметров воздуха и прочих сред, GPS-приемники, RFID-ридеры и многие другие предпочитают этот способ общения иным. Зачастую под каждое устройство написана собственная библиотека, которая незаметно включает в себя описанные выше функции протокола, но бывает и так, что приходится разбираться с устройством самостоятельно. Тогда берем в руки даташит и мастерим на его основе команды для передачи и приема данных.

Не всегда адрес устройства известен заранее, его просто забывают указать производители, особенно часто этим грешат наши китайские друзья. В таком случае используем готовую, имеющуюся в примере к библиотеке Wire программу i2c_scanner, которая простым перебором вычисляет адреса подключенных и откликающихся устройств.

Однако, протокол вполне себе успешно можно применять для обмена данными между контроллерами. Разумеется, один из них, согласно доктрине, будет главным, а другой или другие, ведомыми. Рассмотрим несколько примеров такого взаимодействия.

Возьмем две платы Ардуино и соединим их по сложнейшей схеме SDA-SDA, SCL-SCL. Конечно, по хорошему следовало бы придавить их к плюсу резисторами за 1-10КОм, но для теста и коротких проводов можно и без этих сложностей.

Вариант простой: ведущий передает, ведомый принимает. Это стандартный пример с нашими комментариями.

Ведущий:

#include <Wire.h> // подключаем библиотеку void setup() { Wire.begin(); // запускаем шину i2c без адреса, т.к. это Мастер } byte x = 0; void loop() { Wire.beginTransmission(8); // начало передачи на устройство номер 8 Wire.write("x is "); // отправляем цепочку текстовых байт Wire.write(x); // отправляем байт из переменной Wire.endTransmission(); // останавливаем передачу x++; // увеличиваем значение переменной на 1 delay(500); // ждем полчекунды }

Ведомый:

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

Запускаем монитор на ведомом устройстве и наблюдаем:

Каждые полсекунды появляется новая строка с увеличенным счетчиком, при этом реально отсчет ведется на другом контроллере.

Обратный пример, ведущий запрашивает информацию у ведомого, и тот ее присылает.

Ведущий:

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

Ведомый:

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

На мониторе ведущего видим появляющуюся дважды в секунду одинаковую строку, принятую от ведомого устройства.

Все работает. Традиционно посмотрим, как это выглядит в реальности на шине при помощи логического анализатора:

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

А можно ли принимать и отправлять данные в обе стороны? Конечно. Для демонстрации этого не поленимся собрать схему из двух Ардуин с кнопкой и светодиодом, подключенными к каждой из них.

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

Ведущий:

#include <Wire.h> // библиотека i2c #define BUT 7 // кнопка #define LED 6 // светодиод byte but[2]; // отслеживание кнопки void setup() { pinMode(BUT, INPUT); pinMode(LED, OUTPUT); Wire.begin(); // запускаем шину i2c } void loop() { butt(); // опрос кнопок Wire.requestFrom(8, 1); // запрашиваем 1 байт у ведомого номер 8 while (Wire.available()) { // если данные пришли byte c = Wire.read(); // считываем digitalWrite(LED, c); // отправляем на светодиод } delay(100); // немного отдыхаем и запрашиваем снова } void butt() { static unsigned long timer; if (timer + 50 > millis()) return; // опрос кнопок через 50мс (антидребезг) but[0] = but[1]; but[1] = digitalRead(BUT); if (but[0] && !but[1]) { Wire.beginTransmission(8); // отправляем состояние кнопки на ведомый номер 8 Wire.write(1); // 1 Wire.endTransmission(); // закончили } else if (!but[0] && but[1]) { Wire.beginTransmission(8); // отправляем состояние кнопки на ведомый номер 8 Wire.write(0); // 0 Wire.endTransmission(); // закончили } timer = millis(); }

Ведомый:

#include <Wire.h> // библиотека i2c #define BUT 7 // кнопка #define LED 6 // светодиод byte but[2]; // отслеживание кнопки byte co; // байт для отправки на ведомый void setup() { pinMode(BUT, INPUT); pinMode(LED, OUTPUT); Wire.begin(8); // запускаем шину i2c как ведомый с номером 8 Wire.onRequest(requestEvent); // функция отправки Wire.onReceive(receiveEvent); // функция приема } void loop() { butt(); // опрос кнопок } void butt() { // опрашиваем кнопки, храним состояние в переменной co для отправки static unsigned long timer; if (timer + 50 > millis()) return; but[0] = but[1]; but[1] = digitalRead(BUT); if (but[0] && !but[1]) { co = 1; } else if (!but[0] && but[1]) { co = 0; } } void requestEvent() { // функция отправки срабатывает от сигнала с ведущего Wire.write(co); // отправляем состояние кнопок } void receiveEvent() { while (0 < Wire.available()) { // пока есть пришедшие данные (1 байт за команду) byte c = Wire.read(); // принимаем и отправляем на светодиод digitalWrite(LED, c); } }

Таким образом, успешно осуществляется передача данных в обе стороны. Напомню, что устройств, подключенных к одной шине, может быть до 127 штук, что, согласитесь, открывает очень неплохие возможности для творчества.

Вывод

Если нам потребуется соединить большое количество устройств в небольших габаритах, используя при этом минимум проводов, смело выбираем i2c как надежный, быстрый и довольно простой интерфейс. Кроме того, без него не обойтись при активном подключении модулей от сторонних производителей, а сейчас таковых большинство. В любом случае, знать протокол i2c и уметь его применять должен любой уважающий себя DIY-мастер.

FAQ

Какова скорость передачи данных по шине i2c?
Скорость зависит от тактовой частоты контроллера, размеров пакетов и адаптируется под самое медленное устройство в сети. Для Ардуино 16МГц составляет порядка 100 кбит/с.

Есть ли программная (софтовая) реализация протокола i2c?
Нет, в этом нет смысла, потому что в протоколе i2c (в отличие от UART, рассчитанного на соединение точка-точка) к одной шине может подключаться до 127 устройств, чего более чем достаточно.

Для моих задач не хватает скорости i2c, что делать?
Изучать и использользовать интерфейс SPI. Потребуется больше проводов, но, в теории, скорость передачи данных способна разогнаться до половины тактовой частоты контроллера, то есть 8МГц для Ардуино UNO и ей подобных.

Возможно ли, что адрес подключенных устройств совпадает? Что произойдет в этом случае и как быть?
Теоретически такое возможно, при этом, разумеется, оба устройства не будут нормально работать. Поэтому практически все устройства оснащены возможностью смены адреса. Чаще всего это делается при помощи перемычек, которые можно запаять и распаять, переключателей или джамперов.