Уроки

Как настроить I2C-связь на Arduino

1 комм.

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

Что такое I2C?

c - это аббревиатура от Inter-Integrated Circuit (меж-интеграционная цепь или последовательная асимметричная шина).

I2C - низкоскоростной последовательный протокол связи, подходящий для передачи данных на короткие расстояния. Если вам необходимо передавать данные на большие расстояния, этот протокол не рекомендуется. Пример простой сети I2C показан ниже.

Как видно на диаграмме, преимущество использования I2C состоит в том, что для связи с несколькими устройствами требуется всего два провода.

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

Многие датчики и модули, предназначенные для Arduino используют I2C для связи.

Сеть I2C

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

Ведомое устройство (наследник)

Все ведомые устройства имеют I2C-адрес, который используется для идентификации устройства в сети. I2C-адрес позволяет ведущему устройству передавать данные конкретному ведомому устройству на шине.

Ведущее устройство (мастер)

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

Шина

Шина в I2C - это просто два провода, которые соединяют все I2C-устройства в сети.

Эти два провода называются SDA и SCL. Провод SDA используется для связи между ведущим и ведомым устройствами.

Линия SCL несет тактовый сигнал, используемый для правильной синхронизации связи. Для поддержания обоих проводов в состоянии HIGH необходимы импульсные или подтягивающие (pull-up) резисторы.

Логические уровни

Будьте внимательны при подключении I2C устройств к Arduino.

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

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

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

Использование I2C

Чтобы продемонстрировать, как использовать I2C в Arduino, давайте создадим проект, который посылает данные туда и обратно между двумя ардуинами.

Мы будем использовать I2C связи для изменения скорости мигания светодиода контакта 13 на одном Arduino, в зависимости от положения потенциометра, подключенного к другому Arduino.

Один Arduino будет выступать в качестве мастера, а другой Arduino будет выступать в качестве ведомого.

Пины I2C Arduino

Arduino имеет специальные контакты для I2C, которые имеют встроенные подтягивающие резисторы в соответствии с требованиями протокола I2C.

Для плат Arduino Uno это контакты A4 и A5. Пин A4 - это контакт SDA, а пин A5 - это контакт SCL. В версии Arduino Uno R3 есть еще один набор контактов I2C рядом с USB-разъемом:

Компоненты оборудования

Чтобы создать этот проект, вам понадобятся следующие компоненты:

  1. Arduino Uno - 2 шт.
  2. Потенциометр (10КОм) - 2 шт.
  3. Перемычки

Схема соединения

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

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

Скетч для мастера

У нас есть два Ардуино в нашей сети I2C, так что у нас есть два набора скетчей. Один для мастера Ардуино, а другой для наследника Ардуино. Между двумя эскизами нет большой разницы, как вы увидите позже.

Теперь откройте Arduino IDE и загрузите код ниже на мастер Arduino:

// MASTER

#include <Wire.h>

byte i2c_rcv;               // data received from I2C bus
unsigned long time_start;   // start time in mSec
int stat_LED;               // status of LED: 1 = ON, 0 = OFF
byte value_pot;             // potentiometer position

void setup()
{
	Wire.begin(); // join I2C bus as Master
	
	// initialize global variables
	i2c_rcv = 255;
	time_start = millis();
	stat_LED = 0;
	
	pinMode(13, OUTPUT);    // set pin 13 mode to output
}

void loop()
{
	// read potentiometer position
	value_pot = analogRead(A0);   // read analog value at pin A0 (potentiometer voltage)

	// send potentiometer position to Slave device 0x08
	Wire.beginTransmission(0x08); // informs the bus that we will be sending data to slave device 8 (0x08)
	Wire.write(value_pot);        // send value_pot
	Wire.endTransmission();       // informs the bus and the slave device that we have finished sending data

	Wire.requestFrom(0x08, 1);    // request potentiometer position from slave 0x08
	if(Wire.available()) {	      // read response from slave 0x08
		i2c_rcv = Wire.read();
	}
	
	// blink logic code
	if((millis() - time_start) > (1000 * (float)(i2c_rcv/255))) {
		stat_LED = !stat_LED;
		time_start = millis();
	}
	digitalWrite(13, stat_LED);
}

Объяснение скетча для мастера

Основная часть кода как для ведущего, так и для ведомых устройств - это то, что я называю логическим кодом мигания. Чтобы мигнуть светодиодом 13 на Ардуино, мы должны сделать следующее:

  • Добавим глобальные переменные byte i2c_rcv, int time_start, stat_LED и byte value_pot в верхней части нашего скетча
  • Инициализируйте значения глобальных переменных внутри функции setup()
  • Инициализируйте контакт 13 Arduino как выходной контакт внутри setup() с помощью pinMode()
  • Добавим код логики мигания внутри функции loop()

Библиотека Wire

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

Эта библиотека поставляется в стандартной комплектации с Arduino IDE. Как и в других библиотеках Arduino, библиотека Wire имеет готовые I2C функции, чтобы сделать кодирование проще для нас.

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

#include <Wire.h>

После включения библиотеки мы можем использовать встроенные функции библиотеки.

Первое, что нужно сделать, это подключить устройство к шине I2C. Синтаксис для этого - Wire.begin(address). Адрес является необязательным для мастер-устройств. Итак, для эскиза мастера Arduino, мы просто добавляем код Wire.begin(); внутри setup().

Теперь мы переходим к циклу loop(). Наш код заставит Arduino прочитать значение потенциометра, подключенного к контакту A0, и сохранить его в переменной value_pot.

Отправка данных

После сохранения значения с пина A0 в переменную value_pot, мы можем отправить значение по I2C. Отправка данных по I2C включает в себя три функции:

  • Wire.beginTransmission()
  • Wire.write()
  • Wire.endTransmission()

Wire.beginTransmission()

Мы инициируем команду отправки, сначала информируя устройства на шине о том, что мы будем отправлять данные.

Для этого мы вызываем функцию Wire.beginTransmission(address). Адрес - это I2C-адрес ведомого прибора, который будет принимать данные. Эта функция делает две вещи:

  1. Она информирует шину о том, что мы будем посылать данные.
  2. Он информирует предполагаемого получателя о том, что данные готовы к получению.

Wire.write()

А затем мы отправим значение переменной value_to_send с помощью функции Wire.write(value).

Wire.endTransmission()

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

Наше ведущее устройство также должно получить положение потенциометра от ведомого устройства. Мы делаем это с помощью Wire.requestFrom(), Wire.available() и Wire.read().

Wire.requestFrom()

Полным синтаксисом запроса данных от ведомого устройства является Wire.requestFrom(адрес, количество).

Адрес - это I2C-адрес ведомого устройства, от которого мы должны получить данные, а количество - это количество байтов, которое нам нужно. Для нашего проекта, адрес ведомого устройства 0x08 и нам нужен один байт.

Внутри loop() мы используем Wire.requestFrom(0x08, 1); для запроса одного байта данных от ведомого устройства 0x08.

После выдачи команды Wire.requestFrom(0x08, 1), за ней должна следовать команда чтения для получения ответа от шины I2C.

Write.available()

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

Wire.read();

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

Скетч для наследника (ведомого)

Теперь загрузите этот код ведомому Ардуино:

// SLAVE

#include <Wire.h>

byte i2c_rcv;               // data received from I2C bus
unsigned long time_start;   // start time in mSec
int stat_LED;               // status of LED: 1 = ON, 0 = OFF
byte value_pot;             // potentiometer position

void setup()
{
	Wire.begin(0x08);           // join I2C bus as Slave with address 0x08
	
	// event handler initializations
	Wire.onReceive(dataRcv);    // register an event handler for received data
	Wire.onRequest(dataRqst);   // register an event handler for data requests
	
	// initialize global variables
	i2c_rcv = 255;
	time_start = millis();
	stat_LED = 0;
	
	pinMode(13, OUTPUT);        // set pin 13 mode to output
}

void loop()
{

	value_pot = analogRead(A0); // read analog value at pin A0 (potentiometer voltage)
	
	// blink logic code
        if((millis() - time_start) > (1000 * (float)(i2c_rcv/255))) {
		stat_LED = !stat_LED;
		time_start = millis();
	}
	digitalWrite(13, stat_LED);
}

//received data handler function
void dataRcv(int numBytes)
{
	while(Wire.available()) {	// read all bytes received
		i2c_rcv = Wire.read();
	}
}

// requests data handler function
void dataRqst()
{
	Wire.write(value_pot); // send potentiometer position
}

Объяснение скетча для ведомого

Для ведомого устройства существует небольшая разница в кодировании I2C-связи. Первая разница заключается в адресе Wire.begin(address).

Для ведомых устройств адрес является обязательным. Для нашего проекта адрес для ведомого устройства будет 0x08. Это может быть любой адрес, но убедитесь, что он уникален в сети I2C.

Некоторые I2C ведомые устройства также имеют определенные I2C-адреса, поэтому сначала проверьте спецификацию.

Мы присоединим I2C сеть в качестве ведомого устройства, добавив код Wire.begin(0x08); внутри setup().

Обработчики событий

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

Обработчики событий - это части кода, которые управляют событиями, с которыми наше устройство, скорее всего, столкнется во время работы.

Wire.onReceive()

В части скетча setup() мы добавляем функцию Wire.onReceive(handler) для регистрации функции (обработчика), которая будет управлять полученными данными.

Мы вызываем нашу функцию-обработчик dataRcv(). Обратите внимание, что имя функции может быть любым. В приведенном выше эскизе Wire.onReceive(dataRcv); вызывается в секции setup().

В конце эскиза находится код функции-обработчика. Он инициализируется как void dataRcv(int numBytes). Параметр int numBytes содержит количество байт полученных данных.

Wire.onRequest()

Следующий обработчик события, который мы будем использовать - Wire.onRequest(handler). Эта функция используется на подчиненных устройствах и работает аналогично Wire.onReceive().

Единственное отличие заключается в том, что она обрабатывает события запроса данных. Запросы данных поступают от основных устройств.

В функцию setup() мы добавляем код Wire.onRequest(dataRqst);. А в конце нашего эскиза добавляем функцию void dataRqst(). Обратите внимание, что обработчики Wire.onRequest() не принимают никаких параметров. Функция dataRqst() содержит только Wire.write().

Нам не нужны Wire.beginTransmission() и Wire.endTransmission(), потому что библиотека Wire уже обрабатывает ответы от ведомых устройств.

Тестирование Arduino I2C

А вот и самая захватывающая часть - включение питания и тестирование!

Используя Arduino IDE, загрузите эскиз мастера Arduino в одну из Ардуино. Затем загрузите скетч наследника в другую Arduino.

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

Наш код принимает положение потенциометра мастера и посылает его ведомому устройству через I2C. Затем ведомое устройство использует полученное значение для настройки времени задержки мигания светодиода. То же самое происходит и с положением потенциометра ведомого.

Оригинал

Поделиться
1 июня 2020 в 18:16
Обновлено 29 июня 2020 в 18:29 (редакция)
Опубликовано:
Уроки,

1 комментарий

  1. Vladimir
    6 июля 2020 в 23:32

    Всё чудесно. Не считая того что комментарий можно было перевести на русский.

    Ответить

Добавить комментарий

Ваш E-mail не будет никому виден. Обязательные поля отмечены *