I2C-Bus mit Arduino verstehen: I2C-Scanner, Adresskonflikte lösen & mehrere Sensoren an zwei Kabeln

Was I2C überhaupt ist

I2C (gesprochen „I-Quadrat-C“, von Inter-Integrated Circuit) wurde in den 1980ern von Philips erfunden, um Chips auf einer Platine mit möglichst wenigen Leitungen zu verbinden. Das Ergebnis: Ein Bus mit exakt zwei Signalleitungen, an dem theoretisch bis zu 127 Geräte hängen dürfen.

Ein Gerät ist der Master (dein Arduino oder ESP32) und gibt den Takt vor. Alle anderen sind Slaves und antworten nur, wenn sie mit ihrer Adresse angesprochen werden. Die Kommunikation läuft immer nach demselben Muster ab: Der Master zieht SDA auf Low, während SCL noch High ist (das ist die Start-Bedingung), schickt dann die 7-Bit-Adresse des gewünschten Slaves plus ein Bit für Lesen oder Schreiben. Das angesprochene Gerät antwortet mit einem ACK – einem einzelnen Low-Impuls, der „ja, ich bin da“ bedeutet. Danach fließen die Datenbytes.

Open-Drain: Warum Pull-Up-Widerstände Pflicht sind

Hier steckt der wichtigste Unterschied zu allem, was du bisher am Arduino gemacht hast. Ein normaler GPIO-Pin kann aktiv High und aktiv Low ausgeben. I2C-Pins können das nicht – sie arbeiten im Open-Drain-Modus: Jedes Gerät kann die Leitung nur nach Masse ziehen (Low), aber niemals aktiv auf High treiben.

Wer macht dann High? Die Pull-Up-Widerstände. Sie ziehen die Leitung nach VCC, solange niemand sie nach unten zerrt. Ohne Pull-Ups hängt der Bus in der Luft, und nichts funktioniert.

Wie groß müssen die Pull-Ups sein?

Für eigene Pull-Ups eignen sich die 4,7-kΩ- und 2,2-kΩ-Werte aus dem 600er Widerstands-Sortiment. Je ein Widerstand von SDA nach VCC und von SCL nach VCC – mehr braucht es nicht.

Was du brauchst

Wo liegen die I2C-Pins?

Jedes Board hat seine eigenen. Diese Tabelle klebst du dir am besten an die Wand:

1Der I2C-Scanner – dein wichtigstes Werkzeug

Bevor du auch nur eine Zeile Sensorcode schreibst, läuft dieser Sketch. Er klopft jede Adresse von 1 bis 126 ab und meldet, wer antwortet. Findet der Scanner dein Modul nicht, ist jede Bibliothek zwecklos – dann ist die Verkabelung schuld.

#include <Wire.h>

void setup() {
  Wire.begin();
  Serial.begin(9600);
  while (!Serial) delay(10);
  Serial.println("\nI2C-Scanner gestartet");
}

void loop() {
  byte fehler;
  int gefunden = 0;

  Serial.println("Suche Geraete...");

  for (byte adresse = 1; adresse < 127; adresse++) {
    // Uebertragung starten und sofort beenden.
    // endTransmission() liefert 0, wenn jemand mit ACK geantwortet hat.
    Wire.beginTransmission(adresse);
    fehler = Wire.endTransmission();

    if (fehler == 0) {
      Serial.print("  Geraet gefunden bei 0x");
      if (adresse < 16) Serial.print("0");
      Serial.print(adresse, HEX);
      Serial.print("  (dezimal ");
      Serial.print(adresse);
      Serial.println(")");
      gefunden++;
    }
    else if (fehler == 4) {
      Serial.print("  Unbekannter Fehler bei 0x");
      if (adresse < 16) Serial.print("0");
      Serial.println(adresse, HEX);
    }
  }

  if (gefunden == 0) {
    Serial.println("Kein I2C-Geraet gefunden!");
    Serial.println("-> SDA/SCL vertauscht? GND verbunden? Pull-Ups da?");
  } else {
    Serial.print("Fertig. ");
    Serial.print(gefunden);
    Serial.println(" Geraet(e) am Bus.\n");
  }

  delay(5000);
}

Die Adressen, die dir ständig begegnen

2Verkabelung: Vier Module an zwei Leitungen

Das Schöne am Bus: Alle Module hängen parallel an denselben zwei Leitungen. Auf dem Breadboard nutzt du dafür am besten zwei freie Reihen als SDA- und SCL-Schiene.

* Diese Breakouts haben einen eigenen Spannungsregler und einen Pegelwandler an Bord und vertragen deshalb beides. Der nackte Chip darunter läuft nur mit 3,3 V – häng also nie einen blanken BMP280-Chip ohne Breakout an 5 V.

3Alle Sensoren gleichzeitig auslesen

Jetzt der Beweis, dass es funktioniert: BMP280, MPU-6050 und DS3231 gleichzeitig am Bus, Ausgabe auf dem OLED. Installiere vorher über den Bibliotheksverwalter Adafruit BMP280 Library, Adafruit MPU6050, RTClib, Adafruit SSD1306 und Adafruit GFX Library.

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_BMP280.h>
#include <Adafruit_MPU6050.h>
#include <RTClib.h>

Adafruit_SSD1306 display(128, 64, &Wire, -1);
Adafruit_BMP280  bmp;
Adafruit_MPU6050 mpu;
RTC_DS3231       rtc;

bool bmpOk = false, mpuOk = false, rtcOk = false;

void setup() {
  Serial.begin(9600);
  Wire.begin();

  // --- OLED auf 0x3C ---
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println("OLED (0x3C) nicht gefunden!");
  }
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.setTextSize(1);

  // --- BMP280 auf 0x76 (manche Module: 0x77) ---
  bmpOk = bmp.begin(0x76);
  if (!bmpOk) bmpOk = bmp.begin(0x77);
  if (!bmpOk) Serial.println("BMP280 nicht gefunden (0x76/0x77)");

  // --- MPU-6050 auf 0x69, weil AD0 auf VCC liegt ---
  mpuOk = mpu.begin(0x69);
  if (!mpuOk) Serial.println("MPU-6050 nicht gefunden (0x69)");

  // --- DS3231 auf 0x68 ---
  rtcOk = rtc.begin();
  if (!rtcOk) Serial.println("DS3231 nicht gefunden (0x68)");

  // Uhrzeit beim ersten Start setzen
  if (rtcOk && rtc.lostPower()) {
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    Serial.println("RTC neu gestellt.");
  }

  Serial.println("Setup fertig.");
}

void loop() {
  display.clearDisplay();
  display.setCursor(0, 0);

  // --- Uhrzeit ---
  if (rtcOk) {
    DateTime jetzt = rtc.now();
    display.printf("%02d:%02d:%02d  %02d.%02d.\n",
                   jetzt.hour(), jetzt.minute(), jetzt.second(),
                   jetzt.day(), jetzt.month());
  } else {
    display.println("RTC ?");
  }

  // --- Luftdruck & Temperatur ---
  if (bmpOk) {
    display.printf("T: %.1f C\n", bmp.readTemperature());
    display.printf("p: %.0f hPa\n", bmp.readPressure() / 100.0F);
  } else {
    display.println("BMP280 ?");
  }

  // --- Lage ---
  if (mpuOk) {
    sensors_event_t a, g, temp;
    mpu.getEvent(&a, &g, &temp);
    display.printf("aX:%5.1f aY:%5.1f\n", a.acceleration.x, a.acceleration.y);
    display.printf("aZ:%5.1f\n", a.acceleration.z);
  } else {
    display.println("MPU6050 ?");
  }

  display.display();
  delay(500);
}

Vier I2C-Geräte, vier Adressen, zwei Kabel. Genau dafür wurde der Bus erfunden. Beachte das Muster mit den bmpOk/mpuOk/rtcOk-Flags: So läuft der Sketch weiter, auch wenn ein Modul fehlt – statt in einer while(true)-Endlosschleife hängenzubleiben, siehst du auf dem Display ein Fragezeichen und weißt sofort, wer fehlt.

4Bus-Geschwindigkeit anpassen

Standardmäßig läuft I2C im Standard Mode mit 100 kHz. Das ist konservativ und funktioniert immer. Wenn du ein OLED mit 128x64 Pixeln 20-mal pro Sekunde neu zeichnen willst, wird es damit aber eng – dann lohnt der Fast Mode mit 400 kHz.

void setup() {
  Wire.begin();

  // Bustakt setzen - NACH Wire.begin()!
  Wire.setClock(400000);   // 400 kHz Fast Mode
  // Wire.setClock(100000); // 100 kHz Standard (Default)
  // Wire.setClock(10000);  // 10 kHz - fuer lange Kabel

  Serial.begin(9600);
}

5Adresskonflikte: Wenn Umadressieren nicht geht

Zwei MPU-6050 gleichzeitig? Kein Problem – AD0 des einen auf GND (0x68), des anderen auf VCC (0x69). Aber drei MPU-6050? Oder vier VL53L0X-Sensoren für einen Roboter? Ab hier gehen dir die Adressen aus. Dafür gibt es zwei Lösungen.

Lösung A: Software-Umadressierung (VL53L0X)

Manche Chips lassen sich per Software umadressieren – die neue Adresse gilt allerdings nur bis zum nächsten Stromausfall. Der Trick: Alle Sensoren zunächst über ihren XSHUT-Pin abschalten, dann einen nach dem anderen aufwecken und umadressieren.

#include <Wire.h>
#include <Adafruit_VL53L0X.h>

#define XSHUT_1  2
#define XSHUT_2  3
#define XSHUT_3  4

Adafruit_VL53L0X sensor1, sensor2, sensor3;

void setup() {
  Serial.begin(9600);

  // Alle Sensoren per XSHUT in den Reset ziehen
  pinMode(XSHUT_1, OUTPUT);
  pinMode(XSHUT_2, OUTPUT);
  pinMode(XSHUT_3, OUTPUT);
  digitalWrite(XSHUT_1, LOW);
  digitalWrite(XSHUT_2, LOW);
  digitalWrite(XSHUT_3, LOW);
  delay(10);

  // Sensor 1 aufwecken, auf 0x30 umziehen
  digitalWrite(XSHUT_1, HIGH);
  delay(10);
  if (!sensor1.begin(0x30)) Serial.println("Sensor 1 fehlt!");

  // Sensor 2 aufwecken, auf 0x31 umziehen
  digitalWrite(XSHUT_2, HIGH);
  delay(10);
  if (!sensor2.begin(0x31)) Serial.println("Sensor 2 fehlt!");

  // Sensor 3 bleibt auf der Standardadresse 0x29
  digitalWrite(XSHUT_3, HIGH);
  delay(10);
  if (!sensor3.begin(0x29)) Serial.println("Sensor 3 fehlt!");

  Serial.println("Drei ToF-Sensoren bereit.");
}

void loop() {
  VL53L0X_RangingMeasurementData_t m1, m2, m3;

  sensor1.rangingTest(&m1, false);
  sensor2.rangingTest(&m2, false);
  sensor3.rangingTest(&m3, false);

  Serial.print("Links: ");
  Serial.print(m1.RangeStatus != 4 ? m1.RangeMilliMeter : 0);
  Serial.print(" mm | Mitte: ");
  Serial.print(m2.RangeStatus != 4 ? m2.RangeMilliMeter : 0);
  Serial.print(" mm | Rechts: ");
  Serial.print(m3.RangeStatus != 4 ? m3.RangeMilliMeter : 0);
  Serial.println(" mm");

  delay(200);
}

Damit steuerst du drei VL53L0X-Sensoren gleichzeitig – links, Mitte, rechts. Perfekt für einen Roboter, der Hindernissen ausweichen soll. Mehr zum Sensor selbst steht im Artikel VL53L0X Laser-Entfernungssensor mit Arduino.

Lösung B: Der TCA9548A Multiplexer

Wenn sich ein Chip überhaupt nicht umadressieren lässt – acht identische Sensoren mit fester Adresse zum Beispiel – hilft ein I2C-Multiplexer. Der TCA9548A sitzt zwischen Arduino und Sensoren und schaltet acht getrennte Bus-Kanäle durch. Jeder Kanal darf dieselbe Adresse tragen, weil immer nur einer aktiv ist:

#include <Wire.h>

#define TCA_ADDR 0x70

// Kanal 0-7 am Multiplexer aktivieren
void tcaKanal(uint8_t kanal) {
  if (kanal > 7) return;
  Wire.beginTransmission(TCA_ADDR);
  Wire.write(1 << kanal);   // Bitmaske: genau ein Kanal an
  Wire.endTransmission();
}

void setup() {
  Wire.begin();
  Serial.begin(9600);
  while (!Serial) delay(10);

  // Jeden Kanal einzeln scannen
  for (uint8_t k = 0; k < 8; k++) {
    tcaKanal(k);
    Serial.print("--- Kanal ");
    Serial.print(k);
    Serial.println(" ---");

    for (uint8_t adr = 1; adr < 127; adr++) {
      if (adr == TCA_ADDR) continue;   // den Muxer selbst ueberspringen

      Wire.beginTransmission(adr);
      if (Wire.endTransmission() == 0) {
        Serial.print("  Geraet bei 0x");
        Serial.println(adr, HEX);
      }
    }
  }
  Serial.println("Scan fertig.");
}

void loop() {
  // Beispiel: drei identische Sensoren nacheinander auslesen
  for (uint8_t k = 0; k < 3; k++) {
    tcaKanal(k);
    // ... hier ganz normal den Sensor auslesen,
    //     als haenge nur er allein am Bus
    delay(100);
  }
}

Troubleshooting: Der I2C-Bus schweigt

Praxistipps

• Scanner vor jedem Projekt: Zehn Sekunden Scan sparen dir eine Stunde Bibliotheks-Debugging. Wenn der Scanner das Modul nicht sieht, findet es auch keine Library.
• Adressen dokumentieren: Schreib die Adresse jedes Moduls als Kommentar in den Sketch. Beim nächsten Umbau in sechs Monaten dankst du dir das.
• Ein Modul nach dem anderen: Bau den Bus schrittweise auf und lass nach jedem neuen Modul den Scanner laufen. Dann weißt du sofort, welches Modul den Bus zerlegt.
• endTransmission()-Rückgabewert prüfen: 0 = alles gut, 2 = keine Antwort auf die Adresse, 3 = keine Antwort auf die Daten, 4 = sonstiger Fehler, 5 = Timeout. Diese Zahl sagt dir mehr als jede Vermutung.
• Mehr Pins auf dem ESP32: Der ESP32 hat zwei komplett getrennte I2C-Controller. Mit TwoWire zweiterBus = TwoWire(1); und zweiterBus.begin(sda2, scl2); baust du dir einen zweiten Bus – damit löst du Adresskonflikte ganz ohne Multiplexer.
• OLED sparsam neu zeichnen: Ein voller Bildschirm-Refresh schiebt 1024 Byte über den Bus. Bei 100 kHz dauert das rund 100 ms. Zeichne nur, was sich ändert, oder geh auf 400 kHz.