Grundlagen · 10 Min. Lesezeit

I2C zwei Arduinos verbinden: Master-Slave, onReceive, Structs

Per I2C zwei Arduinos verbinden: Master-Slave-Verdrahtung, Pull-up-Werte, Wire.onReceive und onRequest, Adresse, Structs und ESP32 mit Pegelwandler.

Wenn du per I2C zwei Arduinos verbinden willst, hast du eine der praktischsten Lösungen überhaupt: Du brauchst nur zwei Datenleitungen (SDA und SCL) und eine gemeinsame Masse, und mit der mitgelieferten Wire-Bibliothek steht die Verbindung in ein paar Zeilen. Ein Board ist der Controller (früher Master genannt) und beginnt jedes Gespräch; das andere ist das Target (Slave), hat eine Adresse und hört zu, was ihm geschickt wird, oder antwortet, wenn es gefragt wird. Weil Dutzende Targets an denselben zwei Leitungen hängen können, ist I2C ideal für Projekte, in denen ein Hauptboard mehrere Hilfs-Arduinos steuert.

In diesem Beitrag verbinden wir Schritt für Schritt zwei Arduino Uno per I2C: Verdrahtungs- und Pull-up-Tabelle, Wahl der Adresse, die Funktionen Wire.onReceive und Wire.onRequest, ein einzelnes Byte senden, bidirektionale Kommunikation mit einem Struct, mehrere Arduinos am selben Bus, Kommunikation mit ESP32 und Raspberry Pi Pico über einen Pegelwandler sowie ein Vergleich von I2C und UART. Willst du vorher die I2C-Grundlagen und den Scanner-Sketch auffrischen, lies Was ist I2C?.

Arduino Uno
Arduino Uno: Der I2C-Bus liegt an A4 (SDA) und A5 (SCL); bei R3-Boards ist derselbe Bus zusätzlich an den SDA- und SCL-Pins neben AREF herausgeführt.

Wie arbeiten Controller und Target (Master und Slave) bei I2C?

Bei I2C hängen alle Geräte parallel an denselben zwei Leitungen. SCL ist die Taktleitung, den Takt erzeugt immer der Controller; SDA ist die Datenleitung und wird in beide Richtungen genutzt. Zu Beginn einer Nachricht erzeugt der Controller eine "Start"-Bedingung und sendet dann die 7-Bit-Adresse des Targets zusammen mit dem Lese- oder Schreibbit. Das Target mit dieser Adresse antwortet mit einem ACK (erhalten), indem es die Leitung am Ende jedes Bytes kurz auf LOW zieht; hat niemand diese Adresse, bleibt die Leitung HIGH, das nennt man NACK. Deshalb weiß der Controller bei I2C sofort, ob eine Nachricht angekommen ist. Die wichtigste Regel lautet: Ein Target kann nicht von sich aus sprechen. Selbst wenn es neue Daten hat, wartet es, bis der Controller fragt; der Controller muss es also regelmäßig abfragen. In der Arduino-Dokumentation heißen die Rollen "Controller" und "Peripheral", in der neueren Fassung des I2C-Standards "Controller" und "Target"; gemeint ist dasselbe wie Master und Slave in älterem Code.

Verdrahtung: die I2C-Leitungen zwischen zwei Arduinos

Arduino A (Controller)VerbindungArduino B (Target)Hinweis
A4 (SDA)DirektA4 (SDA)Nicht gekreuzt
A5 (SCL)DirektA5 (SCL)Nicht gekreuzt
GNDDirektGNDPflicht: gemeinsamer Bezug
5VOptional5VNur wenn Board B von Board A versorgt wird
SDA und SCLMit 4,7 kΩ an 5V-Ein Widerstandspaar reicht für den ganzen Bus
Anders als bei UART werden die Leitungen bei I2C nicht gekreuzt: SDA geht an SDA, SCL an SCL. Verbinde außerdem immer die GND beider Boards; ohne gemeinsame Masse kommt keine Verbindung zustande oder es gibt zufällige Fehler. Warum die gemeinsame Masse unverzichtbar ist, liest du in GND und gemeinsame Masse.
BoardSDASCLHinweis
Arduino Uno / NanoA4A5Beim Uno R3 sind SDA und SCL neben AREF derselbe Bus
Arduino Mega 2560D20D21Hat 10-kΩ-Pull-ups auf der Platine
Arduino Leonardo / MicroD2D3Andere Pins als beim Uno
ESP32GPIO 21GPIO 223,3 V; mit Wire.begin(sda, scl) sind andere Pins möglich
Raspberry Pi PicoGP4 (I2C0)GP5 (I2C0)3,3 V; in MicroPython sind andere Pinpaare wählbar

Pull-up-Widerstände: wann und welcher Wert?

Die Teilnehmer am I2C-Bus können die Leitungen nur auf LOW ziehen; auf HIGH bringen sie die Pull-up-Widerstände. Auf den AVR-Boards von Arduino schaltet Wire.begin() an SDA und SCL interne Pull-ups von etwa 20–50 kΩ ein. Mit zwei Unos, kurzen Kabeln und 100 kHz klappt das meistens, aber für I2C sind diese Widerstände schwach; je länger die Leitung, desto langsamer steigen die Flanken und desto mehr Fehler gibt es. Für einen zuverlässigen Bus setz je einen 4,7-kΩ-Widerstand von SDA und von SCL nach 5V. Die Untergrenze ergibt sich aus den 3 mA, die im LOW-Zustand fließen dürfen: R(min) = (5 V - 0,4 V) / 3 mA ≈ 1,5 kΩ. Die Obergrenze bestimmt die Buskapazität: Bei 100 kHz und 200 pF gilt R(max) ≈ 1000 ns / (0,8473 × 200 pF) ≈ 5,9 kΩ. Für die Rechnung nutze das Werkzeug Ohmsches Gesetz, für die Idee dahinter den Beitrag Pull-up- und Pull-down-Widerstand.

SituationEmpfohlener Pull-upHinweis
Zwei Unos, Kabel unter 30 cm, 100 kHz4,7 kΩ (die internen gehen oft auch)Der häufigste Aufbau
50 cm bis 1 m Kabel oder 400 kHz2,2 kΩKabel trotzdem so kurz wie möglich halten
Ein Arduino Mega hängt am BusEventuell keine weiteren nötigDie 10 kΩ des Mega liegen parallel zu den anderen
Module mit Pull-ups am Bus (OLED, RTC, LCD)Gesamten Parallelwiderstand berechnenDer Gesamtwert sollte nicht unter 1,5 kΩ fallen
Arduino mit ESP32 oder PicoDie Widerstände auf beiden Seiten des PegelwandlersNicht direkt verbinden, siehe Abschnitt unten

Adresse wählen: Welche solltest du nehmen?

Die Adresse des Target-Arduinos legst du selbst mit Wire.begin(adresse) fest. Im 7-Bit-Adressraum sind 0x00–0x07 und 0x78–0x7F reserviert, nutzbar ist also der Bereich 0x08–0x77, dezimal 8 bis 119. Hängen weitere Module am Bus, wähle einen Wert, der nicht mit deren Adressen kollidiert; am sichersten schließt du alles an und lässt den I2C-Scanner laufen, um die belegten Adressen zu sehen. Diese Adressen nutzen gängige Module:

AdresseModule, die diese Adresse oft nutzen
0x27 / 0x3FI2C-LCD mit PCF8574
0x3C / 0x3DOLED-Display SSD1306
0x68RTC DS1307 und DS3231, MPU-6050
0x76 / 0x77BMP280 und BME280
0x40Servotreiber PCA9685, INA219
0x48ADC ADS1115
0x57MAX30102, EEPROM AT24C32 auf RTC-Modulen
0x08–0x0FMeist frei; ein guter Bereich für Arduino-Targets

Beispiel 1: ein Byte vom Controller zum Target senden

Im ersten Beispiel liest Board A ein Potentiometer an A0, teilt den Wert durch 4, um ihn in den Bereich 0–255 zu bringen, und schickt ihn zehnmal pro Sekunde als einzelnes Byte an Adresse 8. Board B empfängt das Byte und stellt die Helligkeit der LED an D9 ein. Lade zuerst den Controller-Sketch auf Board A und dann den Target-Sketch auf Board B. Die Wire-Bibliothek ist in der Arduino IDE schon enthalten. Controller-Sketch:

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}

Target-Sketch für Board 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}

Im Target-Sketch sind zwei Stellen entscheidend. Erstens Wire.begin(8): Ein Board, das mit einer Adresse startet, wird zum Target. Zweitens Wire.onReceive(): Sendet der Controller Daten, ruft die Wire-Bibliothek diese Funktion selbst auf und übergibt die Zahl der empfangenen Bytes. Wir legen den Wert in einer volatile-Variablen ab und setzen nur ein "neue Daten"-Flag; LED einstellen und in den seriellen Monitor schreiben passiert in loop(). Beim Controller verrät dir der Rückgabewert von Wire.endTransmission(), was mit der Nachricht passiert ist:

Rückgabe von endTransmission()BedeutungWas tun?
0Erfolg, das Target hat jedes Byte bestätigt-
1Daten passen nicht in den Puffer (mehr als 32 Bytes)Nachricht aufteilen
2Kein ACK auf die AdresseAdresse, Verdrahtung, GND und Versorgung des Targets prüfen
3Kein ACK auf ein DatenbyteTarget beschäftigt oder unerwartete Länge
4Anderer FehlerBus gestört oder Pull-ups fehlen
5ZeitüberschreitungBus hängt; Wiederherstellung mit setWireTimeout() einschalten

onReceive und onRequest: Regeln im Interrupt

  • Kurz halten: Beide Funktionen laufen im I2C-Interrupt. Verwende dort kein delay(), kein Serial.print() und keine langen Berechnungen; leg die Daten in einer Variablen ab und kehr zurück.
  • volatile verwenden: Flags, die im Interrupt geändert und in loop() gelesen werden, deklarierst du als volatile; sonst bemerkt der Compiler die Änderung womöglich nicht. Details im Beitrag Arduino-Interrupts.
  • In onRequest alles auf einmal schreiben: Fragt der Controller Daten an, leg alle Bytes mit einem einzigen Wire.write(array, laenge) in den Puffer. Bereite die Daten vorher vor; einen Sensor in onRequest auszulesen lässt den Controller warten.
  • Die 32-Byte-Grenze: Der Wire-Puffer ist auf AVR 32 Bytes groß. Teile längere Daten auf mehrere Nachrichten auf oder nimm, wenn es wirklich nötig ist, UART.
  • Länge prüfen: Vergleiche die Zahl der in onReceive ankommenden Bytes mit der erwarteten; kommen zu viele oder zu wenige, lies sie aus und verwirf sie.
  • Antwort vorbereiten: Aktualisiere die Berichtsvariablen, bevor das Target eine lange Aufgabe beginnt; so findet der Controller immer eine fertige Antwort.

Beispiel 2: bidirektionale Kommunikation mit einem Struct

In echten Projekten reicht ein Byte nicht: Der Controller schickt einen Befehl, das Target liefert einen Bericht mit mehreren Werten. Statt die Werte von Hand in Bytes zu zerlegen, definierst du besser ein Struct und schickst es unverändert; das ist lesbarer und schneller. Im Beispiel unten stellt der Controller mit einem 2-Byte-Befehl LED und Helligkeit ein und fordert dann mit Wire.requestFrom() einen 7-Byte-Bericht an: den Potentiometerwert (uint16_t), den Tasterzustand (uint8_t) und die Laufzeit des Targets (uint32_t). Die Structs müssen auf beiden Boards identisch sein. Controller-Sketch:

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}

Der Sketch des Target-Boards; die Struct-Definitionen sind exakt dieselben wie beim Controller:

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}

Im Target-Sketch schickt die mit Wire.onRequest() registrierte Funktion das Bericht-Struct unverändert, sobald der Controller Daten anfordert. Der Bericht selbst wird in loop() aktualisiert. Währenddessen sperren wir mit noInterrupts() kurz die Interrupts; fragt der Controller genau in diesem Moment, bekommt er so keinen Wert, der halb alt und halb neu ist. Der empfangene Befehl wird im selben Schutz in eine lokale Variable kopiert. Beim Controller verhindert die Zeile Wire.setWireTimeout(25000, true), dass der Bus für immer hängt, wenn sich ein Kabel löst oder das Target abstürzt: Kommt innerhalb von 25 ms keine Antwort, setzt sich Wire selbst zurück.

Verwende in Structs immer Typen mit fester Größe wie uint8_t, int16_t und uint32_t. Auf dem Arduino Uno hat ein int 2 Bytes, auf dem ESP32 4; ein double hat auf dem Uno 4 Bytes und auf dem ESP32 8. __attribute__((packed)) verhindert, dass der Compiler Füllbytes zwischen die Felder setzt; ohne das wäre dasselbe Struct auf dem Uno 7 und auf dem ESP32 8 Bytes groß, und die Daten verrutschen. AVR und ESP32 sind beide Little-Endian, die Bytereihenfolge stimmt also überein. Bits und Bytes frischst du im Beitrag Zahlensysteme und Bitoperationen auf.

Mehrere Arduinos am selben Bus

Der große Vorteil von I2C gegenüber UART: Viele Targets teilen sich dieselben zwei Leitungen. Gib jedem Target-Board eine eigene Adresse (zum Beispiel 8, 9 und 10), verbinde alle SDA, alle SCL und alle GND und nutze für den ganzen Bus nur ein Paar Pull-up-Widerstände. Der Controller kann ein Array mit Adressen der Reihe nach durchgehen, jedem Board einen Befehl schicken und seinen Bericht abfragen. Je länger der Bus, desto größer seine Kapazität; halte die Boards nah beieinander, die gesamte Kabellänge bei ein paar Dutzend Zentimetern und bleib notfalls bei 100 kHz. Am selben Bus kannst du auch Module wie ein I2C-LCD oder ein OLED betreiben; solange die Adressen nicht kollidieren, arbeitet alles problemlos zusammen.

I2C zwischen Arduino und ESP32: Pegelwandlung

Der Arduino Uno arbeitet mit 5 V, der ESP32 mit 3,3 V, und die Pins des ESP32 vertragen keine 5 V. Da Wire.begin() beim Uno die internen Pull-ups an 5 V legt, zieht eine direkte Verbindung die ESP32-Pins auf 5 V. Umgekehrt gibt es ebenfalls ein Problem: Ziehst du den Bus nur auf 3,3 V, brauchen die I2C-Eingänge des Uno für HIGH mindestens 0,7 × 5 V = 3,5 V, und 3,3 V liegen darunter. Die richtige Lösung ist ein bidirektionaler BSS138-Pegelwandler mit Pull-ups auf beiden Seiten: Die HV-Seite kommt an 5V und A4/A5 des Uno, die LV-Seite an 3V3 und GPIO 21/22 des ESP32, die GND sind gemeinsam. Die genaue Verdrahtung zeigt Logikpegelwandler. Der ESP32 kann ab Core-Version 2.0.1 auch als Target arbeiten, aber die Daten genau im Moment von onRequest bereitzustellen ist beim ESP32 schwieriger; am problemlosesten ist deshalb der ESP32 als Controller und der Uno als Target. Der Sketch unten liest denselben Bericht vom Uno-Target aus Beispiel 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-Controller mit dem Raspberry Pi Pico (MicroPython)

Auch der Raspberry Pi Pico arbeitet mit 3,3 V und wird deshalb ebenso über einen Pegelwandler an den Uno angeschlossen. MicroPython kennt keine C-Structs, aber das Modul struct erledigt dasselbe: Das Format "<HBI" steht für ein uint16_t, ein uint8_t und ein uint32_t in Little-Endian ohne Füllbytes und passt genau zum 7-Byte-Bericht des Uno. Der Code scannt zuerst den Bus und gibt die gefundenen Adressen aus, dann schickt er dem Uno-Target einen Befehl und liest dessen Bericht. Bist du neu beim Pico, beginne mit Was ist der 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 oder UART? Ein Vergleich

MerkmalI2CUART
LeitungenSDA, SCL und GND (direkt)TX, RX und GND (gekreuzt)
Anzahl der GeräteEin Controller und bis zu 112 AdressenNur zwei Geräte
Wer beginnt das Gespräch?Nur der ControllerBeide Seiten, jederzeit
Typische Geschwindigkeit100 kHz oder 400 kHz9600–115200 Baud
EntfernungAuf der Platine und kurze Kabel (bis 1 m)Einige Meter; mit RS-485 viel weiter
EmpfangsbestätigungJa (ACK und NACK)Nein; eigene Prüfung nötig
Nachrichtengröße (Wire)32-Byte-PufferFortlaufender Bytestrom
Hardware am Arduino UnoA4 und A5D0 und D1 (mit USB geteilt) oder SoftwareSerial

Kurz gesagt: Nimm I2C, wenn die Boards im selben Gehäuse sitzen, ein Hauptboard mehrere Helfer steuert und du sicher sein willst, dass jede Nachricht ankommt. Liegen die Boards mehrere Meter auseinander, müssen beide Seiten jederzeit senden können oder gibt es einen langen, kontinuierlichen Datenstrom, passt UART besser; Details stehen in Serielle Schnittstelle UART. Brauchst du sehr viel Tempo, ist SPI die dritte Option.

Häufige Fehler und ihre Lösungen

  • endTransmission() gibt 2 zurück: Das Target antwortet unter dieser Adresse nicht. Prüfe, ob die Adresse in beiden Sketches gleich ist, ob SDA und SCL vertauscht sind, ob GND verbunden ist und ob der Target-Sketch hochgeladen wurde; bestätige die Adresse mit dem I2C-Scanner.
  • SDA und SCL wie bei UART kreuzen: Bei I2C geht SDA an SDA und SCL an SCL; mit gekreuzten Leitungen wird kein Gerät gefunden.
  • Das Programm hängt in onReceive: In der Interrupt-Funktion stehen Serial.print() oder delay(), oder es wird eine neue Wire-Übertragung gestartet. Kopiere dort nur die Daten und erledige die Arbeit in loop().
  • Die Werte kommen verdreht oder verschoben an: Die Struct-Definitionen unterscheiden sich, ein Typ wie int mit boardabhängiger Größe wurde verwendet oder packed fehlt. Nutze Typen fester Größe und dieselbe Definition.
  • Zufällige Fehler bei längeren Kabeln: Die internen Pull-ups reichen nicht. Ergänze externe 4,7-kΩ- oder 2,2-kΩ-Widerstände, kürze die Kabel und bleib bei 100 kHz.
  • Mit ESP32 läuft der Bus gar nicht oder der ESP32 wird warm: 5 V und 3,3 V wurden direkt verbunden. Setz einen bidirektionalen Pegelwandler dazwischen.

Zwei Arduinos per I2C sprechen zu lassen ist der einfachste Weg, ein großes Projekt in kleine, unabhängige Teile zu zerlegen: Ein Board kümmert sich um Display und Bedienung, die anderen lesen Sensoren oder treiben Motoren. Prüfe die Verbindung zuerst mit dem Ein-Byte-Beispiel und geh dann zum bidirektionalen Struct-Beispiel über. In der BlueGrays-App findest du mit Schaltplan und Schritt-für-Schritt-Code die Projekte zur unidirektionalen und bidirektionalen Kommunikation zwischen 2 Arduinos, das I2C-LCD, den I2C-Taschenrechner, das ESP32-I2C-LCD und die Uhr mit DS1307-RTC.

Häufige Fragen

Wie verbinde ich zwei Arduinos per I2C?

Verbinde A4 (SDA), A5 (SCL) und GND der beiden Boards direkt miteinander. Ein Board startet mit Wire.begin() als Controller, das andere mit einer Adresse wie Wire.begin(8) als Target. Der Controller sendet mit beginTransmission, write und endTransmission und fordert mit requestFrom Daten an; das Target antwortet über seine Funktionen onReceive und onRequest.

Braucht I2C zwischen zwei Arduinos Pull-up-Widerstände?

Ja; I2C-Leitungen sind Open-Drain, den HIGH-Pegel liefern die Pull-up-Widerstände. Die internen Pull-ups des Arduino funktionieren mit zwei Boards und kurzen Kabeln oft, für einen zuverlässigen Bus empfehlen sich aber je 4,7 kΩ von SDA und SCL nach 5V.

Wie viele Arduinos passen an einen I2C-Bus?

Mit 7-Bit-Adressen sind 112 Adressen von 0x08 bis 0x77 nutzbar, theoretisch also 112 Targets. In der Praxis begrenzen die gesamte Buskapazität und die Kabellänge; mit einer Handvoll Boards und kurzen Kabeln hast du keine Probleme.

Kann ein Arduino-Slave von sich aus Daten an den Master senden?

Nein. Bei I2C beginnt immer der Controller die Kommunikation; das Target antwortet nur über onRequest, wenn es gefragt wird. Soll das Target neue Daten melden, fragt der Controller regelmäßig nach, oder das Target zieht einen separaten Interrupt-Pin auf LOW, um ihn zu alarmieren.

Kann ich Arduino und ESP32 direkt per I2C verbinden?

Davon ist abzuraten. Der Uno arbeitet mit 5 V, der ESP32 mit 3,3 V, und die internen Pull-ups des Uno ziehen die ESP32-Pins auf 5 V. Nutze einen bidirektionalen Pegelwandler wie den BSS138 und mach den ESP32 zum Controller und den Uno zum Target.

Was ist der Unterschied zwischen I2C und UART beim Arduino?

I2C bringt mit zwei Leitungen und Adressen viele Geräte an einen Bus und bestätigt jedes Byte mit einem ACK, aber nur der Controller kann ein Gespräch beginnen. UART verbindet nur zwei Geräte, die Leitungen werden gekreuzt, und beide Seiten können jederzeit senden. I2C passt zu mehreren Boards auf kurzer Distanz, UART zu langen Kabeln und kontinuierlichen Datenströmen.

Alle Projekte ansehen
Einweg-Kommunikation zwischen 2 Arduinos
AR-57Mittel
Premium

Einweg-Kommunikation zwischen 2 Arduinos

Du bringst zwei Arduinos über ein einziges Kabel zum Reden: Drückst du den Knopf am einen, geht die LED am anderen an, drückst du noch einmal, geht sie aus.

4.4(37)
50
Bidirektionale Kommunikation zwischen 2 Arduinos
AR-58Mittel
Premium

Bidirektionale Kommunikation zwischen 2 Arduinos

Zwei Arduinos werden per Kabel verbunden und unterhalten sich: Drückst du den Knopf am einen, geht am anderen das Licht an, drückst du noch einmal, geht es aus.

4.5(20)
26
Verwendung des LCD-Bildschirms mit I2C
AR-32Anfänger
Premium

Verwendung des LCD-Bildschirms mit I2C

Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.

4.8(53)
70
Arduino I2C-Rechner
AR-94Mittel
Premium

Arduino I2C-Rechner

Es handelt sich um ein Arduino-basiertes Taschenrechnerprojekt, das Addition, Subtraktion, Multiplikation und Division mit einer 4x4-Folientastatur und einem 16x2 I2C-LCD-Display durchführt. Dank I2C ist der Anschluss des Displays mit nur 2 Kabeln möglich, was den Kabelsalat reduziert und mehr Pins für die Verwendung offen hält. Die Eingabe von Dezimalzahlen und die Unterstützung negativer Zahlen sind ebenfalls möglich.

5.0(31)
43
ESP32 I2C-LCD-Display (16×2)
ES-17Mittel
Premium

ESP32 I2C-LCD-Display (16×2)

In diesem Projekt schließen wir ein 16x2-Zeichen-LCD über I2C an den ESP32 an und zeigen Text an. Dank I2C reichen 2 Datenpins (SDA und SCL) statt der 6+ Pins einer klassischen Parallelverbindung. Der Code schreibt eine feste Nachricht in die erste Zeile und einen sekündlich steigenden Zähler in die zweite. Beim Start gibt ein I2C-Scanner die Adresse des Displays im Serial Monitor aus (meist 0x27 oder 0x3F).

4.9(23)
40
Digitale Uhr mit ESP32 und RTC DS1307 (I2C + LCD)
ES-18Mittel
Premium

Digitale Uhr mit ESP32 und RTC DS1307 (I2C + LCD)

In diesem Projekt zeigen wir Uhrzeit und Datum auf einem 16x2-I2C-LCD-Display mithilfe des DS1307-Echtzeituhrmoduls (RTC) an. Das DS1307 ist ein batteriegestütztes RTC, das die Uhrzeit auch dann beibehält, wenn das ESP32 ausgeschaltet ist. Beide Module teilen sich denselben I2C-Bus (SDA/SCL), sodass wir mit nur zwei Signalkabeln die Steuerung mehrerer Geräte erlernen. So lernen Sie das I2C-Protokoll und die Funktionsweise von RTC-Modulen in der Praxis kennen.

4.6(26)
40
Paddle-Ball-Spiel - SSD1306
AR-86Mittel
Premium

Paddle-Ball-Spiel - SSD1306

Ein Ball, zwei Schläger und du: Du spielst Tischtennis, eines der allerersten Videospiele, auf einem kleinen OLED-Display.

4.5(47)
65
Punktmatrixuhr und Kalender (MAX7219, DS1307)
AR-84Mittel
Premium

Punktmatrixuhr und Kalender (MAX7219, DS1307)

Eine leuchtende Tafel für Tisch oder Wand, die Uhrzeit und Datum als Laufschrift zeigt.

5.0(37)
59