Основы · 10 мин чтения

I2C между двумя Arduino: master и slave, onReceive и структуры

Связь двух Arduino по I2C (master и slave): подключение, номинал подтяжки, Wire.onReceive и onRequest, выбор адреса, передача структур и согласование уровней с ESP32.

I2C между двумя Arduino (master и slave) — один из самых практичных способов связать две платы: нужны всего два сигнальных провода (SDA и SCL) и общая земля, а с библиотекой Wire, которая входит в состав Arduino, всё настраивается в несколько строк. Одна плата становится контроллером (раньше его называли master, ведущий) и всегда начинает разговор первой; вторая — целевым устройством (slave, ведомое): у неё есть адрес, и она либо слушает то, что ей прислали, либо отвечает на запрос. К одним и тем же двум проводам можно подключить десятки целевых устройств, поэтому I2C очень удобен в проектах, где одна главная плата управляет несколькими вспомогательными Arduino.

В этой статье мы шаг за шагом соединяем две Arduino Uno по I2C: таблица подключения и подтяжек, выбор адреса, функции Wire.onReceive и Wire.onRequest, отправка одного байта, двусторонний обмен данными с помощью структуры, несколько Arduino на одной шине, связь с ESP32 и Raspberry Pi Pico через преобразователь уровней и сравнение I2C с UART. Если хочешь сначала освежить основы I2C и разобрать скетч-сканер, загляни в статью «Что такое I2C?».

Arduino Uno
Arduino Uno: шина I2C выведена на пины A4 (SDA) и A5 (SCL); на платах R3 та же шина продублирована на контактах SDA и SCL рядом с AREF.

Как в I2C работают контроллер и целевое устройство (master и slave)?

В I2C все устройства подключаются параллельно к одним и тем же двум линиям. SCL — линия тактового сигнала, и управляет ею всегда контроллер; SDA — линия данных, по ней данные идут в обе стороны. Чтобы начать сообщение, контроллер формирует условие «старт», а затем отправляет 7-битный адрес целевого устройства вместе с битом чтения или записи. Устройство с таким адресом отвечает сигналом ACK (принято): в конце каждого байта оно ненадолго притягивает линию к LOW; если такого адреса ни у кого нет, линия остаётся в HIGH — это называется NACK. Поэтому в I2C контроллер сразу узнаёт, дошло ли сообщение. Самое важное правило: целевое устройство не может заговорить первым. Даже когда у него появились новые данные, оно ждёт, пока контроллер спросит, так что контроллеру приходится регулярно его опрашивать. В документации Arduino эти роли называются «controller» и «peripheral», а в новой редакции стандарта I2C — «controller» и «target»; это то же самое, что master и slave в старом коде.

Подключение: провода I2C между двумя Arduino

Arduino A (контроллер)СоединениеArduino B (целевое устройство)Примечание
A4 (SDA)НапрямуюA4 (SDA)Без перекрещивания
A5 (SCL)НапрямуюA5 (SCL)Без перекрещивания
GNDНапрямуюGNDОбязательно: общая опорная точка
5VПо желанию5VТолько если плата B питается от платы A
SDA и SCL4,7 kΩ к 5V-Одной пары резисторов хватает на всю шину
В отличие от UART, провода I2C не перекрещиваются: SDA идёт к SDA, а SCL — к SCL. Обязательно соедини и GND обеих плат: без общей земли связь либо не установится вовсе, либо будет сыпать случайными ошибками. Почему общая земля обязательна, читай в статье «GND и общая земля».
ПлатаSDASCLПримечание
Arduino Uno / NanoA4A5На Uno R3 пины SDA и SCL рядом с AREF — та же шина
Arduino Mega 2560D20D21На плате есть подтягивающие резисторы 10 kΩ
Arduino Leonardo / MicroD2D3Пины не те, что у Uno
ESP32GPIO 21GPIO 223,3 V; через Wire.begin(sda, scl) можно выбрать другие пины
Raspberry Pi PicoGP4 (I2C0)GP5 (I2C0)3,3 V; в MicroPython можно выбрать и другие пары пинов

Подтягивающие резисторы: когда они нужны и какого номинала?

Устройства на шине I2C умеют только притягивать линии к LOW; обратно в HIGH их возвращают подтягивающие резисторы. На AVR-платах Arduino функция Wire.begin() включает на SDA и SCL внутреннюю подтяжку примерно 20–50 kΩ. С двумя Uno, короткими проводами и на 100 kHz этого обычно хватает, но для I2C такие резисторы слабоваты: чем длиннее провода, тем медленнее нарастают фронты, и начинаются ошибки. Для надёжной шины добавь по одному резистору 4,7 kΩ от SDA к 5V и от SCL к 5V. Нижнюю границу задаёт ток 3 mA, допустимый в состоянии LOW: R(min) = (5 V - 0,4 V) / 3 mA ≈ 1,5 kΩ. Верхнюю определяет ёмкость шины: на 100 kHz для шины ёмкостью 200 pF R(max) ≈ 1000 нс / (0,8473 × 200 pF) ≈ 5,9 kΩ. Для расчётов пригодится утилита «Закон Ома», а сам принцип подтяжки разобран в статье «Подтягивающие и стягивающие резисторы (pull-up и pull-down)».

СитуацияРекомендуемая подтяжкаПримечание
Две Uno, провода короче 30 см, 100 kHz4,7 kΩ (часто работают и внутренние)Самый распространённый вариант
Провода от 50 см до 1 м или 400 kHz2,2 kΩПровода всё равно делай как можно короче
На шине есть Arduino MegaДополнительные резисторы могут не понадобитьсяРезисторы 10 kΩ на Mega включаются параллельно остальным
На шине модули со своей подтяжкой (OLED, RTC, LCD)Посчитай общее параллельное сопротивлениеИтог не должен опускаться ниже 1,5 kΩ
Arduino с ESP32 или PicoРезисторы преобразователя уровней с каждой стороныНапрямую не подключай; смотри раздел ниже

Выбор адреса: какой взять?

Адрес целевой Arduino выбираешь ты: он задаётся в Wire.begin(адрес). В 7-битном адресном пространстве диапазоны 0x00–0x07 и 0x78–0x7F зарезервированы, поэтому использовать можно 0x08–0x77, то есть от 8 до 119 в десятичной записи. Если на шине есть другие модули, возьми значение, которое не совпадает с их адресами; надёжнее всего подключить всё и запустить I2C-сканер, чтобы увидеть, какие адреса заняты. Вот адреса распространённых модулей:

АдресМодули, которые часто его используют
0x27 / 0x3FI2C LCD с адаптером на PCF8574
0x3C / 0x3DOLED-дисплей SSD1306
0x68RTC DS1307 и DS3231, MPU-6050
0x76 / 0x77BMP280 и BME280
0x40Драйвер сервоприводов PCA9685, INA219
0x48АЦП ADS1115
0x57MAX30102, EEPROM AT24C32 на модулях RTC
0x08–0x0FОбычно свободны; хороший диапазон для целевых Arduino

Пример 1: отправка байта от контроллера целевому устройству

В первом примере плата A считывает потенциометр на A0, делит значение на 4, чтобы уложить его в диапазон 0–255, и 10 раз в секунду отправляет одним байтом на адрес 8. Плата B принимает этот байт и задаёт яркость светодиода на D9. Сначала загрузи скетч контроллера в плату A, затем скетч целевого устройства в плату B. Библиотека Wire идёт в комплекте с Arduino IDE, устанавливать ничего не нужно. Скетч контроллера:

C++ (Arduino IDE)
1// Denetleyici (master): potansiyometre değerini hedefe gönderir / Controller (master): sends the pot value to the target
2#include <Wire.h>
3
4const byte TARGET_ADDR = 8;          // hedef kartın adresi / address of the target board
5
6void setup() {
7  Wire.begin();                      // adres verilmedi = denetleyici / no address = controller
8  Serial.begin(9600);
9}
10
11void loop() {
12  byte value = analogRead(A0) / 4;   // 0-1023 -> 0-255
13  Wire.beginTransmission(TARGET_ADDR);
14  Wire.write(value);
15  byte status = Wire.endTransmission();   // 0 = başarılı / 0 = success
16  if (status != 0) {
17    Serial.print(F("I2C hatasi / error: "));
18    Serial.println(status);          // 2 = adres yanıt vermedi / 2 = no ACK on address
19  }
20  delay(100);
21}

Скетч целевого устройства для платы B:

C++ (Arduino IDE)
1// Hedef (slave): gelen baytla LED parlaklığını ayarlar / Target (slave): sets the LED brightness from the received byte
2#include <Wire.h>
3
4const byte MY_ADDR = 8;              // bu kartın adresi / this board's address
5const int LED_PIN = 9;               // PWM pini / PWM pin
6
7volatile byte received = 0;
8volatile bool newData = false;
9
10void onReceiveEvent(int howMany) {   // kesme içinde çalışır: kısa tut / runs inside an interrupt: keep it short
11  for (int i = 0; i < howMany; i++) received = Wire.read();   // son bayt kalır / keep the last byte
12  newData = true;
13}
14
15void setup() {
16  Wire.begin(MY_ADDR);               // adresle başlat = hedef / start with an address = target
17  Wire.onReceive(onReceiveEvent);
18  pinMode(LED_PIN, OUTPUT);
19  Serial.begin(9600);
20}
21
22void loop() {
23  if (newData) {
24    newData = false;
25    analogWrite(LED_PIN, received);
26    Serial.println(received);        // Serial'ı kesmenin dışında kullan / use Serial outside the interrupt
27  }
28}

В скетче целевого устройства два ключевых момента. Первый — Wire.begin(8): плата, запущенная с адресом, становится целевым устройством. Второй — Wire.onReceive(): когда контроллер присылает данные, библиотека Wire сама вызывает эту функцию и передаёт ей число принятых байтов. Значение мы сохраняем в переменной с модификатором volatile и лишь поднимаем флаг «есть новые данные»; управление светодиодом и вывод в монитор порта выполняются в loop(). На стороне контроллера значение, которое возвращает Wire.endTransmission(), показывает, что стало с сообщением:

Значение endTransmission()Что означаетЧто делать
0Успех: целевое устройство подтвердило каждый байт-
1Данные не поместились в буфер (больше 32 байт)Раздели сообщение на части
2Нет ACK на адресПроверь адрес, провода, GND и питание целевого устройства
3Нет ACK на байт данныхЦелевое устройство занято или получило данные неожиданной длины
4Другая ошибкаВозможно, на шине помехи или нет подтяжки
5Тайм-аутШина зависла; включи восстановление через setWireTimeout()

onReceive и onRequest: правила внутри прерывания

  • Делай их короткими: обе функции выполняются внутри прерывания I2C. Не используй в них delay(), Serial.print() и долгие вычисления: сохрани данные в переменную и выходи.
  • Используй volatile: флаги, которые меняются в прерывании и читаются в loop(), объявляй как volatile, иначе компилятор может не заметить изменение. Подробности — в статье «Прерывания в Arduino».
  • В onRequest пиши всё сразу: когда контроллер запрашивает данные, клади все байты в буфер одним вызовом Wire.write(массив, длина). Готовь данные заранее: если читать датчик прямо в onRequest, контроллеру придётся ждать.
  • Ограничение в 32 байта: буфер Wire на AVR вмещает 32 байта. Более длинные данные раздели на несколько сообщений или, если без этого никак, перейди на UART.
  • Проверяй длину: сравнивай число байтов, пришедших в onReceive, с ожидаемым; если их больше или меньше, вычитай их из буфера и отбрось.
  • Готовь ответ заранее: обновляй переменные отчёта до того, как целевое устройство возьмётся за долгую задачу, — тогда контроллер всегда найдёт готовый ответ.

Пример 2: двусторонняя связь с помощью структуры

В реальных проектах одного байта мало: контроллер отправляет команду, а целевое устройство возвращает отчёт из нескольких значений. Вместо того чтобы вручную разбивать значения на байты, проще и быстрее описать структуру (struct) и отправить её как есть. В примере ниже контроллер 2-байтовой командой включает светодиод и задаёт его яркость, а затем через Wire.requestFrom() запрашивает у целевого устройства 7-байтовый отчёт: значение потенциометра (uint16_t), состояние кнопки (uint8_t) и время работы целевой платы (uint32_t). Структуры на обеих платах должны быть одинаковыми. Скетч контроллера:

C++ (Arduino IDE)
1// Denetleyici: komut gönderir, rapor ister / Controller: sends a command, requests a report
2#include <Wire.h>
3
4struct __attribute__((packed)) Command {   // denetleyici -> hedef / controller -> target (2 bayt / bytes)
5  uint8_t ledOn;
6  uint8_t brightness;
7};
8
9struct __attribute__((packed)) Report {    // hedef -> denetleyici / target -> controller (7 bayt / bytes)
10  uint16_t potValue;
11  uint8_t buttonPressed;
12  uint32_t uptimeMs;
13};
14
15const byte TARGET_ADDR = 8;
16
17void setup() {
18  Wire.begin();
19  Wire.setClock(100000);                   // standart hız 100 kHz / standard mode 100 kHz
20  Wire.setWireTimeout(25000, true);        // hat takılırsa 25 ms'de kurtul / recover if the bus hangs for 25 ms
21  Serial.begin(9600);
22}
23
24void loop() {
25  Command cmd;
26  cmd.ledOn = 1;
27  cmd.brightness = (millis() / 20) % 256;  // yavaşça artan parlaklık / slowly rising brightness
28
29  Wire.beginTransmission(TARGET_ADDR);
30  Wire.write((const uint8_t*)&cmd, sizeof(cmd));
31  byte err = Wire.endTransmission();
32
33  Report r;
34  byte n = Wire.requestFrom(TARGET_ADDR, (byte)sizeof(Report));
35  if (err == 0 && n == sizeof(Report)) {
36    Wire.readBytes((uint8_t*)&r, sizeof(r));
37    Serial.print(F("Pot: "));
38    Serial.print(r.potValue);
39    Serial.print(F("  Buton / button: "));
40    Serial.print(r.buttonPressed);
41    Serial.print(F("  Sure / uptime ms: "));
42    Serial.println(r.uptimeMs);
43  } else {
44    while (Wire.available()) Wire.read();  // yarım veriyi at / drop partial data
45    Serial.println(F("Hedef yanit vermedi / target not responding"));
46  }
47  delay(200);
48}

Скетч целевой платы; определения структур в точности те же, что и у контроллера:

C++ (Arduino IDE)
1// Hedef: komutu uygular, istenince rapor gönderir / Target: applies the command, sends a report on request
2#include <Wire.h>
3
4struct __attribute__((packed)) Command {   // denetleyicideki yapının aynısı / same struct as on the controller
5  uint8_t ledOn;
6  uint8_t brightness;
7};
8
9struct __attribute__((packed)) Report {
10  uint16_t potValue;
11  uint8_t buttonPressed;
12  uint32_t uptimeMs;
13};
14
15const byte MY_ADDR = 8;
16const int LED_PIN = 9;
17const int BUTTON_PIN = 2;
18
19Command cmd;
20Report report;
21volatile bool newCmd = false;
22
23void onReceiveEvent(int howMany) {
24  if (howMany != sizeof(Command)) {        // beklenmeyen uzunluk: at / unexpected length: discard
25    while (Wire.available()) Wire.read();
26    return;
27  }
28  Wire.readBytes((uint8_t*)&cmd, sizeof(cmd));
29  newCmd = true;
30}
31
32void onRequestEvent() {                    // denetleyici veri istedi / the controller asked for data
33  Wire.write((const uint8_t*)&report, sizeof(report));   // tek seferde yaz / write it in one go
34}
35
36void setup() {
37  pinMode(LED_PIN, OUTPUT);
38  pinMode(BUTTON_PIN, INPUT_PULLUP);
39  Wire.begin(MY_ADDR);
40  Wire.onReceive(onReceiveEvent);
41  Wire.onRequest(onRequestEvent);
42}
43
44void loop() {
45  uint16_t pot = analogRead(A0);
46  uint8_t pressed = (digitalRead(BUTTON_PIN) == LOW);
47  uint32_t now = millis();
48
49  noInterrupts();                          // kopyalarken onRequest araya girmesin / keep onRequest out while copying
50  report.potValue = pot;
51  report.buttonPressed = pressed;
52  report.uptimeMs = now;
53  Command c = cmd;
54  bool fresh = newCmd;
55  newCmd = false;
56  interrupts();
57
58  if (fresh) analogWrite(LED_PIN, c.ledOn ? c.brightness : 0);
59}

В скетче целевого устройства функция, зарегистрированная через Wire.onRequest(), отправляет структуру отчёта как есть каждый раз, когда контроллер запрашивает данные. Сам отчёт обновляется в loop(). На время обновления мы на мгновение приостанавливаем прерывания вызовом noInterrupts(): если контроллер спросит именно в этот момент, ему не достанется значение, наполовину старое и наполовину новое. Пришедшая команда под той же защитой копируется в локальную переменную. На стороне контроллера строка Wire.setWireTimeout(25000, true) не даёт шине зависнуть навсегда, если отошёл провод или целевое устройство перестало отвечать: если ответа нет в течение 25 мс, Wire сбрасывает себя.

В структурах всегда используй типы фиксированного размера: uint8_t, int16_t и uint32_t. На Arduino Uno тип int занимает 2 байта, на ESP32 — 4; double — 4 байта на Uno и 8 на ESP32. __attribute__((packed)) запрещает компилятору вставлять между полями байты выравнивания; без него одна и та же структура занимала бы 7 байт на Uno и 8 на ESP32, и данные бы сместились. И AVR, и ESP32 используют порядок байтов little-endian, так что здесь всё совпадает. Освежить знания о битах и байтах поможет статья «Системы счисления и побитовые операции».

Несколько Arduino на одной шине

Главное преимущество I2C перед UART в том, что к одним и тем же двум проводам можно подключить много целевых устройств. Дай каждой целевой плате свой адрес (например, 8, 9 и 10), соедини все SDA, все SCL и все GND и поставь одну пару подтягивающих резисторов на всю шину. Контроллер может пройтись в цикле по массиву адресов, отправляя каждой плате команду и запрашивая её отчёт. Чем длиннее шина, тем больше её ёмкость: держи платы рядом, не делай общую длину проводов больше нескольких десятков сантиметров и при необходимости оставайся на 100 kHz. На ту же шину можно повесить и модули вроде I2C LCD или OLED: пока адреса не совпадают, всё прекрасно работает вместе.

I2C между Arduino и ESP32: согласование уровней

Arduino Uno работает от 5 V, а ESP32 — от 3,3 V, причём пины ESP32 не рассчитаны на 5 V. Wire.begin() на Uno подключает внутреннюю подтяжку к 5 V, поэтому при прямом соединении двух плат на пинах ESP32 окажется 5 V. Обратный вариант тоже не годится: если подтянуть шину только к 3,3 V, входам I2C на Uno для уровня HIGH нужно минимум 0,7 × 5 V = 3,5 V, и 3,3 V до этого порога не дотягивают. Правильное решение — двунаправленный преобразователь уровней на BSS138 с подтягивающими резисторами по обе стороны: сторона HV идёт к 5V и A4/A5 платы Uno, сторона LV — к 3V3 и GPIO 21/22 платы ESP32, а GND общий. Подробная схема подключения — в статье «Преобразователь логических уровней». ESP32 умеет работать и целевым устройством начиная с версии ядра 2.0.1, но готовить данные прямо в момент onRequest на ESP32 сложнее, поэтому меньше всего хлопот со схемой, где ESP32 — контроллер, а Uno — целевое устройство. Скетч ниже читает тот же отчёт с целевой Uno из примера 2:

C++ (Arduino IDE)
1// ESP32 denetleyici, Arduino Uno hedeften rapor okur / ESP32 controller reads the report from an Arduino Uno target
2#include <Wire.h>
3
4struct __attribute__((packed)) Report {    // Uno'daki yapıyla birebir aynı / exactly the same as on the Uno
5  uint16_t potValue;
6  uint8_t buttonPressed;
7  uint32_t uptimeMs;
8};
9
10const uint8_t TARGET_ADDR = 8;
11
12void setup() {
13  Serial.begin(115200);
14  Wire.begin(21, 22);                      // SDA = GPIO 21, SCL = GPIO 22 (seviye dönüştürücü üzerinden / through a level shifter)
15  Wire.setClock(100000);
16}
17
18void loop() {
19  Report r;
20  uint8_t n = Wire.requestFrom(TARGET_ADDR, (uint8_t)sizeof(Report));
21  if (n == sizeof(Report)) {
22    Wire.readBytes((uint8_t*)&r, sizeof(r));
23    Serial.printf("Pot: %u  Buton / button: %u  Sure / uptime: %lu ms\n",
24                  (unsigned int)r.potValue, (unsigned int)r.buttonPressed, (unsigned long)r.uptimeMs);
25  } else {
26    Serial.println("Uno yanit vermedi / Uno not responding");
27  }
28  delay(500);
29}

Контроллер I2C на Raspberry Pi Pico (MicroPython)

Raspberry Pi Pico тоже работает от 3,3 V, поэтому к Uno подключается точно так же — через преобразователь уровней. В MicroPython нет структур языка C, но ту же работу выполняет модуль struct: формат «<HBI» означает uint16_t, uint8_t и uint32_t в порядке little-endian и без выравнивания — в точности 7-байтовый отчёт Uno. Код сначала сканирует шину и выводит найденные адреса, затем отправляет команду целевой Uno и читает её отчёт. Если Pico для тебя в новинку, начни со статьи «Что такое Raspberry Pi Pico?».

MicroPython
1from machine import I2C, Pin
2import struct, time
3
4i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=100000)   # seviye dönüştürücü üzerinden / through a level shifter
5print("Bulunan adresler / found:", [hex(a) for a in i2c.scan()])
6
7while True:
8    i2c.writeto(8, bytes([1, 128]))                  # Command: ledOn = 1, brightness = 128
9    data = i2c.readfrom(8, 7)                        # Report: 7 bayt / 7 bytes
10    pot, button, uptime = struct.unpack("<HBI", data)   # küçük endian, dolgusuz / little-endian, no padding
11    print("Pot:", pot, "Buton:", button, "ms:", uptime)
12    time.sleep(0.5)

I2C или UART? Сравнение

ПараметрI2CUART
ПроводаSDA, SCL и GND (напрямую)TX, RX и GND (крест-накрест)
Число устройствОдин контроллер и до 112 адресовТолько два устройства
Кто начинает разговор?Только контроллерЛюбая сторона в любой момент
Типичная скорость100 kHz или 400 kHz9600–115200 бод
РасстояниеВ пределах платы и короткие провода (до 1 м)Несколько метров; с RS-485 гораздо дальше
Подтверждение доставкиЕсть (ACK и NACK)Нет; проверку нужно добавлять самостоятельно
Размер сообщения (Wire)Буфер 32 байтаНепрерывный поток байтов
Аппаратная часть на Arduino UnoA4 и A5D0 и D1 (общие с USB) или SoftwareSerial

Коротко: выбирай I2C, когда платы стоят в одном корпусе, когда одна главная плата управляет несколькими вспомогательными и когда важно знать, что каждое сообщение дошло. Если между платами несколько метров, если обе стороны должны отправлять данные когда угодно или если идёт длинный непрерывный поток данных, лучше подойдёт UART; подробности — в статье «Последовательная связь UART». А если нужна высокая скорость, третий вариант — SPI.

Частые ошибки и их решения

  • endTransmission() возвращает 2: целевое устройство не отвечает по этому адресу. Проверь, что адрес в обоих скетчах одинаковый, что SDA и SCL не перепутаны, что GND соединён и что скетч целевого устройства загружен; подтверди адрес I2C-сканером.
  • SDA и SCL перекрещены, как в UART: в I2C линия SDA идёт к SDA, а SCL — к SCL; с перекрещёнными проводами ни одно устройство не находится.
  • Программа зависает внутри onReceive: в функции прерывания вызывается Serial.print() или delay() либо запускается ещё одна транзакция Wire. Там только копируй данные, а работу выполняй в loop().
  • Значения приходят перемешанными или со сдвигом: определения структур на платах отличаются, использован тип вроде int, размер которого зависит от платы, или не указан packed. Бери типы фиксированного размера и одно и то же определение.
  • Случайные ошибки при удлинении проводов: внутренней подтяжки не хватает. Добавь внешние резисторы 4,7 kΩ или 2,2 kΩ, укороти провода и оставь скорость 100 kHz.
  • После подключения ESP32 шина перестаёт работать или ESP32 греется: 5 V и 3,3 V соединены напрямую. Поставь между ними двунаправленный преобразователь уровней.

Связать две Arduino по I2C — самый простой способ разбить большой проект на небольшие независимые части: одна плата отвечает за дисплей и общение с пользователем, а остальные читают датчики или управляют моторами. Сначала проверь связь на примере с одним байтом, а потом переходи к двустороннему примеру со структурой. В приложении BlueGrays есть схемы подключения и пошаговый код для проектов односторонней и двусторонней связи 2 Arduino, I2C LCD, калькулятора на I2C, I2C LCD на ESP32 и часов с RTC DS1307.

Частые вопросы

Как две Arduino общаются по I2C?

Соедини напрямую пины A4 (SDA), A5 (SCL) и GND двух плат. Одна плата запускается как контроллер через Wire.begin(), другая — как целевое устройство с адресом, например Wire.begin(8). Контроллер отправляет данные с помощью beginTransmission, write и endTransmission и запрашивает их через requestFrom; целевое устройство отвечает в функциях onReceive и onRequest.

Нужны ли подтягивающие резисторы для I2C между двумя Arduino?

Да: линии I2C работают с открытым стоком, поэтому уровень HIGH создают подтягивающие резисторы. С двумя платами и короткими проводами часто хватает внутренней подтяжки Arduino, но для надёжной шины рекомендуется добавить по 4,7 kΩ от SDA и от SCL к 5V.

Сколько Arduino можно подключить к одной шине I2C?

При 7-битной адресации доступно 112 адресов от 0x08 до 0x77, так что теоретически помещается 112 целевых устройств. На практике предел задают общая ёмкость шины и длина проводов; с несколькими платами и короткими проводами проблем не будет.

Может ли ведомая Arduino (slave) сама отправить данные ведущей (master)?

Нет. В I2C обмен всегда начинает контроллер; целевое устройство отвечает через onRequest только тогда, когда его спросили. Если целевому устройству нужно сообщить о новых данных, контроллер регулярно его опрашивает либо целевое устройство притягивает к LOW отдельный пин прерывания, чтобы привлечь внимание контроллера.

Можно ли соединить Arduino и ESP32 по I2C напрямую?

Не рекомендуется. Uno работает от 5 V, а ESP32 — от 3,3 V, и внутренняя подтяжка Uno поднимает напряжение на пинах ESP32 до 5 V. Возьми двунаправленный преобразователь уровней, например на BSS138, и сделай ESP32 контроллером, а Uno — целевым устройством.

Чем I2C отличается от UART на Arduino?

I2C объединяет много устройств на одной шине с помощью двух проводов и адресов и сигналом ACK подтверждает, что каждый байт дошёл, но начинать обмен может только контроллер. UART связывает только два устройства, его провода перекрещиваются, и любая сторона может отправлять данные когда захочет. I2C подходит для нескольких плат, стоящих рядом; UART — для длинных проводов и непрерывных потоков данных.

Все проекты
Односторонняя связь между двумя Arduino
AR-57Средний
Premium

Односторонняя связь между двумя Arduino

Ты заставляешь две Arduino разговаривать по одному проводу: нажми кнопку на одной, и на другой загорится светодиод, нажми снова — погаснет.

4.4(37)
50
Двусторонняя связь между двумя Arduino
AR-58Средний
Premium

Двусторонняя связь между двумя Arduino

Две Arduino соединены проводами и разговаривают друг с другом: нажми кнопку на одной, и на другой загорится свет, нажми снова — погаснет.

4.5(20)
26
LCD-экран с I2C
AR-32Новичок
Premium

LCD-экран с I2C

Дай своему Arduino собственный экран и заставь его написать первое сообщение. Двухстрочный LCD-экран подключается всего несколькими проводами; в верхней строке появляется приветствие, затем второе…

4.8(53)
70
Калькулятор на Arduino с I2C
AR-94Средний
Premium

Калькулятор на Arduino с I2C

Калькулятор на Arduino, который выполняет сложение, вычитание, умножение и деление с помощью плёночной клавиатуры 4x4 и LCD-дисплея 16x2 с I2C. Благодаря I2C дисплей подключается всего 2 проводами, поэтому проводов меньше, а свободных пинов больше. Поддерживаются ввод дробных чисел и отрицательные числа.

5.0(31)
43
I2C LCD-дисплей (16x2) на ESP32
ES-17Средний
Premium

I2C LCD-дисплей (16x2) на ESP32

В этом проекте символьный LCD-экран 16x2 подключается к ESP32 по протоколу I2C и выводит текст. Благодаря I2C экраном можно управлять всего двумя пинами данных (SDA и SCL), не тратя 6+ пинов, как при классическом параллельном подключении. Код печатает постоянное сообщение в первой строке и счётчик, растущий каждую секунду, во второй. Кроме того, при запуске работает сканер I2C, который выводит адрес дисплея в монитор порта.

4.9(23)
40
Цифровые часы на ESP32 и DS1307 RTC (I2C + LCD)
ES-18Средний
Premium

Цифровые часы на ESP32 и DS1307 RTC (I2C + LCD)

В этом проекте время и дата из модуля часов реального времени (RTC) DS1307 выводятся на I2C LCD-экран 16x2. DS1307 — RTC с резервной батарейкой, который хранит время даже при выключенной ESP32. Оба модуля делят одну шину I2C (SDA/SCL), и ты узнаёшь, как управлять несколькими устройствами всего по двум сигнальным проводам. Проект даёт практические знания о протоколе I2C, работе модуля RTC и динамическом выводе данных на LCD-экран.

4.6(26)
40
Игра в пинг-понг — SSD1306
AR-86Средний
Premium

Игра в пинг-понг — SSD1306

Мяч, две ракетки и ты: на маленьком OLED-экране ты играешь в настольный теннис — одну из самых первых видеоигр.

4.5(47)
65
Часы и календарь на матрице (MAX7219, DS1307)
AR-84Средний
Premium

Часы и календарь на матрице (MAX7219, DS1307)

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

5.0(37)
59