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?».

Как в 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 и SCL | 4,7 kΩ к 5V | - | Одной пары резисторов хватает на всю шину |
| Плата | SDA | SCL | Примечание |
|---|---|---|---|
| Arduino Uno / Nano | A4 | A5 | На Uno R3 пины SDA и SCL рядом с AREF — та же шина |
| Arduino Mega 2560 | D20 | D21 | На плате есть подтягивающие резисторы 10 kΩ |
| Arduino Leonardo / Micro | D2 | D3 | Пины не те, что у Uno |
| ESP32 | GPIO 21 | GPIO 22 | 3,3 V; через Wire.begin(sda, scl) можно выбрать другие пины |
| Raspberry Pi Pico | GP4 (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 kHz | 4,7 kΩ (часто работают и внутренние) | Самый распространённый вариант |
| Провода от 50 см до 1 м или 400 kHz | 2,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 / 0x3F | I2C LCD с адаптером на PCF8574 |
| 0x3C / 0x3D | OLED-дисплей SSD1306 |
| 0x68 | RTC DS1307 и DS3231, MPU-6050 |
| 0x76 / 0x77 | BMP280 и BME280 |
| 0x40 | Драйвер сервоприводов PCA9685, INA219 |
| 0x48 | АЦП ADS1115 |
| 0x57 | MAX30102, EEPROM AT24C32 на модулях RTC |
| 0x08–0x0F | Обычно свободны; хороший диапазон для целевых Arduino |
Пример 1: отправка байта от контроллера целевому устройству
В первом примере плата A считывает потенциометр на A0, делит значение на 4, чтобы уложить его в диапазон 0–255, и 10 раз в секунду отправляет одним байтом на адрес 8. Плата B принимает этот байт и задаёт яркость светодиода на D9. Сначала загрузи скетч контроллера в плату A, затем скетч целевого устройства в плату B. Библиотека Wire идёт в комплекте с 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:
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). Структуры на обеих платах должны быть одинаковыми. Скетч контроллера:
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}Скетч целевой платы; определения структур в точности те же, что и у контроллера:
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 сбрасывает себя.
Несколько 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:
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?».
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? Сравнение
| Параметр | I2C | UART |
|---|---|---|
| Провода | SDA, SCL и GND (напрямую) | TX, RX и GND (крест-накрест) |
| Число устройств | Один контроллер и до 112 адресов | Только два устройства |
| Кто начинает разговор? | Только контроллер | Любая сторона в любой момент |
| Типичная скорость | 100 kHz или 400 kHz | 9600–115200 бод |
| Расстояние | В пределах платы и короткие провода (до 1 м) | Несколько метров; с RS-485 гораздо дальше |
| Подтверждение доставки | Есть (ACK и NACK) | Нет; проверку нужно добавлять самостоятельно |
| Размер сообщения (Wire) | Буфер 32 байта | Непрерывный поток байтов |
| Аппаратная часть на Arduino Uno | A4 и A5 | D0 и 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
Ты заставляешь две Arduino разговаривать по одному проводу: нажми кнопку на одной, и на другой загорится светодиод, нажми снова — погаснет.

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

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

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

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

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

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

Часы и календарь на матрице (MAX7219, DS1307)
Светящееся табло для стола или стены, которое показывает время и дату бегущей строкой.
Другие статьи
Приложение BlueGrays
Собери эту схему шаг за шагом в телефоне
Схема подключения, код и список деталей на одном экране. 500+ проектов на Arduino, ESP32 и Pico готовы к сборке.
Наведи камеру телефона
Наведи камеру на код — откроется магазин приложений на телефоне.
или открыть магазин

