I²C: Ein Bus, zwei Leitungen, viele Sensoren

I²C: Ein Bus, zwei Leitungen, viele Sensoren

https://bildung.social/@oerinformatik/

https://oer-informatik.de/i2c-bus

I²C, Bussystem, Mikrocontroller, Pull-up-Widerstand, Open-Drain, I²C-Adresse, Wire-Bibliothek, ESP32, ESP8266, Arduino, BME280, Logic-Analyzer

tl/dr; (ca. 30 min Lesezeit): I²C verbindet einen Mikrocontroller über nur zwei Leitungen mit vielen Sensoren, Displays und Speicherbausteinen. Du lernst die Kennzeichen des Busses kennen: Open-Drain-Leitungen mit Pull-up-Widerständen, Adressen statt Auswahlleitungen, Bestätigung jedes Bytes und Taktraten von 100 kHz bis 1 MHz. Du liest ein I²C-Telegramm, bemisst Pull-up-Widerstände und schließt Bausteine an Arduino, ESP8266 und ESP32 an – mit einer Checkliste, was Du vorher im Datenblatt und in der Bibliotheksdokumentation prüfen solltest [AI-Assisted]. (Zuletzt geändert am 03.11.2026)

Disclaimer: Teile des Textes stammen von einer KI. Inhalte sind nicht automatisch zuverlässig; überprüfe Fakten und zitiere vertrauenswürdige Quellen.

Dieser Artikel ist Teil einer Artikelreihe zu Hardware-Schnittstellen von Mikrocontrollern: I²C / SPI

Schon fit in diesem Thema? Nutze die Kann-Liste und die Leitfragen unter dem Artikel als Checkliste, ob Du die relevanten Kompetenzen bereits hast. Hier klicken, um Kann-Liste ein- oder auszublenden

Eine kleine Wetterstation auf dem Schulhof: Ein ESP32 misst mit einem BME280 Temperatur, Luftfeuchte und Luftdruck, zeigt die Werte auf einem OLED-Display an und schaltet über eine Port-Erweiterung Leuchtdioden. Drei Bausteine, aber am Mikrocontroller sind dafür nur zwei Datenleitungen belegt. Möglich macht das der I²C-Bus (gesprochen „I-Quadrat-C“, englisch „I-squared-C“; Abkürzung für Inter-Integrated Circuit, oft auch als I2C oder IIC geschrieben). Er ist die wohl verbreitetste Schnittstelle, wenn ein Mikrocontroller mit Sensoren, Displays, Echtzeituhren oder Speichern auf derselben Platine oder im selben Gehäuse spricht.

Steckbrief: Was I²C ausmacht

I²C wurde 1982 von Philips entwickelt, um die Chips in Fernsehgeräten mit wenigen Leitungen zu verbinden. Heute pflegt NXP die Spezifikation (UM10204, I²C-bus specification and user manual, Rev. 7 von 2021). Seit dieser Revision heißen die Rollen Controller (früher Master) und Target (früher Slave). In Datenblättern, Bibliotheken und älteren Unterlagen begegnen Dir meist noch die alten Begriffe; gemeint ist dasselbe.

Was I²C von den anderen Schnittstellen eines Mikrocontrollers unterscheidet:

• Adressen statt Auswahlleitungen: Alle Teilnehmer hängen parallel an denselben zwei Leitungen. Wen der Controller meint, steht im ersten Byte jedes Telegramms. Ein weiterer Sensor kostet daher keinen zusätzlichen Pin am Mikrocontroller – bei SPI braucht jedes Gerät eine eigene Auswahlleitung.

• Quittung für jedes Byte: Nach jedem Byte meldet der Empfänger mit einem Bestätigungsbit (Acknowledge, ACK), dass er es erhalten hat. Antwortet niemand, merkt der Controller das sofort. Darauf beruht auch der I²C-Scanner, mit dem Du später alle Teilnehmer am Bus findest.

• Wired-AND auf beiden Leitungen: Kein Teilnehmer treibt eine Leitung aktiv auf HIGH. Dadurch kann ein langsames Target den Takt anhalten (Clock Stretching), und zwei Controller können erkennen, dass sie gleichzeitig senden (Arbitrierung).

I²C hat einige Verwandte, die Dir in Datenblättern begegnen: TWI (Two-Wire Interface) ist der Name, den Atmel/Microchip für dieselbe Schnittstelle in den AVR-Mikrocontrollern des Arduino Uno verwendet. SMBus (System Management Bus, z. B. für Akkus und Mainboards) baut auf I²C auf, legt aber engere Pegel- und Zeitgrenzen fest. Und hinter den Steckverbindern Qwiic (SparkFun) und STEMMA QT (Adafruit) steckt ein vierpoliger I²C-Anschluss mit 3,3 V, mit dem sich Breakout-Module ohne Löten verketten lassen.

Leitungen und Potenziale

Ein I²C-Anschluss besteht aus vier Leitungen:

Auf Breakout-Modulen, die neben I²C auch SPI beherrschen, heißen die Anschlüsse oft doppelt: „SDA/SDI“ und „SCL/SCK“.

Open-Drain und Pull-up: Warum niemand HIGH treibt

Die Ausgänge aller I²C-Teilnehmer sind Open-Drain-Ausgänge (bei bipolaren Transistoren Open-Collector): Ein Transistor kann die Leitung nach Masse ziehen (LOW) oder sperren. Einen Transistor nach oben, der die Leitung aktiv auf HIGH treibt, gibt es nicht. Den HIGH-Pegel stellt ein Pull-up-Widerstand R_\mathrm{P} her, der jede Leitung mit der Versorgungsspannung verbindet.

Sobald irgendein Teilnehmer seinen Transistor einschaltet, ist die Leitung LOW. Nur wenn alle sperren, ist sie HIGH. Das entspricht einer UND-Verknüpfung der einzelnen Ausgänge, die allein durch die Verdrahtung entsteht: Wired-AND. Zwei Vorteile ergeben sich daraus:

• Es gibt keinen Kurzschluss, wenn zwei Teilnehmer gleichzeitig senden. Bei Gegentaktausgängen würde der eine nach 3,3 V treiben und der andere nach Masse.

• Jeder Teilnehmer kann jederzeit „mithören“, ob der Pegel auf der Leitung dem entspricht, was er selbst ausgeben wollte. Darauf beruhen Clock Stretching und Arbitrierung.

Die Kehrseite: Der Übergang von LOW nach HIGH ist langsam. Die Leitung bildet mit allen angeschlossenen Eingängen und der Verdrahtung eine Kapazität, die nur über den Pull-up-Widerstand geladen wird. Deshalb ist I²C langsamer als SPI, und deshalb kommt es auf die richtige Größe von R_\mathrm{P} an.

Fehlen die Pull-ups ganz, funktioniert der Bus nicht: Die Leitungen bleiben auf LOW oder „schweben“ undefiniert. Viele fertige Module (BME280-, OLED- oder RTC-Breakouts) haben bereits Pull-ups an Bord, meist 4,7 kΩ oder 10 kΩ. Die internen Pull-ups der Mikrocontroller (bei AVR etwa 20 bis 50 kΩ, beim ESP32 um 45 kΩ) sind für mehr als ein paar Zentimeter Leitung zu hochohmig.

Pegel und gemeinsame Masse

I²C legt die Pegel nicht als feste Spannungen fest, sondern relativ zur Versorgungsspannung V_\mathrm{DD}: Als LOW gilt sicher alles unter 0{,}3 \cdot V_\mathrm{DD}, als HIGH alles über 0{,}7 \cdot V_\mathrm{DD}. Bei 3,3 V sind das 0,99 V und 2,31 V, bei 5 V 1,5 V und 3,5 V. Daraus folgen zwei Regeln:

• Alle Teilnehmer brauchen ein gemeinsames Bezugspotenzial. Die Pegel auf SDA und SCL werden gegen Masse gemessen; ohne verbundene GND-Leitungen sind sie bedeutungslos. I²C ist nicht galvanisch getrennt. Wird eine Trennung gebraucht, etwa zu einem Sensor an einer anderen Stromversorgung, gibt es dafür I²C-Isolatoren (z. B. ISO1540).

• 3,3 V und 5 V nicht einfach mischen. Ziehen die Pull-ups eines 5-V-Moduls den Bus auf 5 V, liegen an den Pins eines ESP32 oder ESP8266 5 V an. Beide sind laut Hersteller nicht für 5 V an den GPIO-Pins ausgelegt. Umgekehrt erkennt ein 5-V-Baustein mit der Schwelle 0{,}7 \cdot 5\ \mathrm{V} = 3{,}5\ \mathrm{V} einen 3,3-V-Pegel nicht sicher als HIGH.

Die saubere Lösung für gemischte Busse ist ein bidirektionaler Pegelwandler mit einem MOSFET je Leitung (Schaltung nach NXP-Applikationsschrift AN10441, als fertiges Modul meist mit dem Transistor BSS138). Er besitzt auf jeder Seite eigene Pull-ups an 3,3 V bzw. 5 V und funktioniert in beide Richtungen, weil I²C nur LOW aktiv treibt. Spezielle ICs wie der PCA9306 erledigen das ebenfalls. Viele Breakout-Module für 5-V-Systeme bringen einen Spannungsregler und einen solchen Pegelwandler bereits mit – das Datenblatt des Moduls (nicht nur des Chips) verrät es.

Pull-up-Widerstände bemessen

Für den Pull-up-Widerstand gibt es eine untere und eine obere Grenze.

Untere Grenze – der Low-Strom: Zieht ein Teilnehmer die Leitung auf LOW, fließt der Strom I = (V_\mathrm{DD} - V_\mathrm{OL}) / R_\mathrm{P} durch seinen Transistor. Im Standard und Fast Mode darf ein Ausgang höchstens 3 mA aufnehmen und muss dabei unter V_\mathrm{OL} = 0{,}4\ \mathrm{V} bleiben:

R_\mathrm{P,min} = \frac{V_\mathrm{DD} - V_\mathrm{OL,max}}{I_\mathrm{OL}} = \frac{3{,}3\ \mathrm{V} - 0{,}4\ \mathrm{V}}{3\ \mathrm{mA}} \approx 967\ \Omega

Obere Grenze – die Anstiegszeit: Gibt der Transistor die Leitung frei, lädt sich die Buskapazität C_\mathrm{b} über R_\mathrm{P} auf. Die Anstiegszeit t_\mathrm{r} wird zwischen 0{,}3 \cdot V_\mathrm{DD} und 0{,}7 \cdot V_\mathrm{DD} gemessen; für eine RC-Ladekurve gilt t_\mathrm{r} = \ln(0{,}7/0{,}3) \cdot R_\mathrm{P} \cdot C_\mathrm{b} \approx 0{,}8473 \cdot R_\mathrm{P} \cdot C_\mathrm{b}. Die Spezifikation erlaubt im Standard Mode höchstens 1000 ns, im Fast Mode 300 ns:

R_\mathrm{P,max} = \frac{t_\mathrm{r}}{0{,}8473 \cdot C_\mathrm{b}}

Für eine Buskapazität von 200 pF ergibt das im Standard Mode 1000\ \mathrm{ns} / (0{,}8473 \cdot 200\ \mathrm{pF}) \approx 5{,}9\ \mathrm{k}\Omega und im Fast Mode etwa 1,77 kΩ. Die Grafik zeigt, was das bedeutet: Mit 10 kΩ erreicht die Leitung die HIGH-Schwelle erst nach rund 2,4 µs – für 100 kHz (5 µs HIGH-Phase) knapp, für 400 kHz zu spät.

Die Buskapazität setzt sich aus den Eingängen der Teilnehmer (je bis etwa 10 pF) und der Verdrahtung zusammen; bei Flachband- oder verdrillten Leitungen kannst Du grob mit 50 bis 100 pF je Meter rechnen.

Achtung bei mehreren Modulen: Bringt jedes Breakout-Modul eigene Pull-ups mit, liegen diese parallel. Fünf Module mit je 4,7 kΩ ergeben

R_\mathrm{ges} = \frac{4{,}7\ \mathrm{k}\Omega}{5} = 940\ \Omega < R_\mathrm{P,min} \approx 967\ \Omega

Der Low-Strom liegt dann mit 2{,}9\ \mathrm{V} / 940\ \Omega \approx 3{,}1\ \mathrm{mA} über der Grenze, und die Teilnehmer erreichen den LOW-Pegel womöglich nicht mehr sicher. Bei vielen Modulen entfernst Du deshalb überzählige Pull-ups; manche Module haben dafür Lötbrücken (Jumper).

Nachrichtenaufbau: Wie ein I²C-Telegramm aussieht

Jede Übertragung beginnt und endet mit einer besonderen Bedingung, die nur der Controller erzeugt. Dazwischen werden Bytes übertragen, jeweils gefolgt von einem Bestätigungsbit. Für den Takt gilt eine einfache Regel: SDA darf sich nur ändern, solange SCL LOW ist. Während SCL HIGH ist, liest der Empfänger das Bit. Eine Änderung von SDA bei SCL HIGH ist deshalb kein Datenbit, sondern ein Steuersignal:

• Startbedingung (S): SDA fällt, während SCL HIGH ist. Alle Targets werden aufmerksam.

• Adressbyte: sieben Adressbits, höchstwertiges Bit (MSB) zuerst, dahinter das Richtungsbit R/\overline{\mathrm{W}}: 0 = Controller schreibt, 1 = Controller liest.

• ACK/NACK: Im neunten Takt gibt der Sender SDA frei. Der Empfänger zieht SDA auf LOW (ACK, „verstanden“) oder lässt es HIGH (NACK, „nicht da“ oder „genug“).

• Datenbytes: beliebig viele, jedes mit acht Bit plus ACK/NACK.

• Stoppbedingung (P): SDA steigt, während SCL HIGH ist. Der Bus ist wieder frei.

• Wiederholte Startbedingung (Repeated Start, Sr): eine neue Startbedingung ohne vorheriges Stopp, um die Richtung zu wechseln, ohne den Bus freizugeben.

Das Adressbyte ergibt sich aus der 7-Bit-Adresse, indem Du sie um eine Stelle nach links schiebst und das R/\overline{\mathrm{W}}-Bit anhängst:

\text{Adressbyte} = 2 \cdot \text{Adresse} + \mathrm{R}/\overline{\mathrm{W}}

Für den BME280 mit der Adresse 0\mathrm{x}76 = 111\,0110_2 heißt das: Schreiben mit 1110\,1100_2 = 0\mathrm{xEC}, Lesen mit 1110\,1101_2 = 0\mathrm{xED}. Datenblätter geben die Adresse mal als 7-Bit-Wert (0x76), mal als 8-Bit-Adressbyte (0xEC/0xED) an. Die Arduino-Bibliotheken erwarten immer den 7-Bit-Wert.

Das Impulsdiagramm zeigt den Anfang eines typischen Zugriffs: Der Controller sendet die Adresse 0x76 mit W, das Target bestätigt, dann folgt die Nummer des Registers, das gelesen werden soll.

Register lesen und schreiben

Die meisten I²C-Bausteine sind intern wie ein kleiner Speicher organisiert: Jede Einstellung und jeder Messwert liegt in einem Register mit einer eigenen Nummer (Registeradresse). Beim BME280 steht zum Beispiel im Register 0xD0 die Chip-ID 0x60, ab 0xF7 liegen die Rohwerte von Druck, Temperatur und Feuchte.

Schreiben ist ein einziges Telegramm: Start · Adresse + W · ACK · Registeradresse · ACK · Datenbyte · ACK · Stopp.

Lesen braucht zwei Phasen. Zuerst schreibt der Controller die Registeradresse in den Registerzeiger des Bausteins, dann wechselt er mit einem Repeated Start die Richtung und holt die Daten ab. Nach dem letzten gewünschten Byte antwortet er mit NACK, damit das Target SDA freigibt und der Controller die Stoppbedingung erzeugen kann. Bei mehreren Bytes zählen die meisten Bausteine den Registerzeiger selbstständig weiter (Auto-Increment).

Clock Stretching und mehrere Controller

Weil SCL ebenfalls eine Open-Drain-Leitung ist, darf ein Target, das noch nicht bereit ist, SCL nach einem Byte auf LOW festhalten. Der Controller wartet, bis SCL wieder HIGH wird. Dieses Clock Stretching nutzen z. B. manche Sensoren während einer laufenden Messung. Nicht jeder Controller unterstützt es unbegrenzt; beim ESP8266 lässt sich die Wartezeit mit Wire.setClockStretchLimit() einstellen.

Senden zwei Controller gleichzeitig, verliert bei der Arbitrierung derjenige, der HIGH ausgeben wollte, aber LOW auf SDA liest; er zieht sich zurück, ohne dass Daten verloren gehen.

Adressen und Adresskonflikte

Mit sieben Bit lassen sich 128 Adressen bilden. Die Bereiche 0x00 bis 0x07 und 0x78 bis 0x7F sind reserviert (z. B. 0x00 für den General Call an alle, 0x78 bis 0x7B als Kennung für 10-Bit-Adressen), sodass 112 Adressen für Bausteine bleiben. Die Adresse ist meist zum Teil im Chip festgelegt; über einen oder mehrere Adresspins (A0, A1, A2, ADDR, SDO o. Ä.) lassen sich die unteren Bits einstellen. So können mehrere gleiche Bausteine am selben Bus betrieben werden.

Haben zwei Teilnehmer dieselbe Adresse, antworten beide gleichzeitig. Wegen des Wired-AND gewinnt dann in jedem Bit die 0; der Controller liest Unsinn und kann die beiden nicht unterscheiden. Die Tabelle zeigt einen typischen Fall: Ein DS3231-Uhrenmodul und ein MPU-6050 belegen beide 0x68. Lösungen in dieser Reihenfolge:

1. Adresspin umstellen: AD0 des MPU-6050 auf HIGH legen, dann antwortet er unter 0x69.

2. Zweiten Bus verwenden: Der ESP32 hat zwei I²C-Controller (Wire und Wire1), beim ESP8266 lässt sich eine zweite Software-Instanz auf anderen Pins anlegen.

3. Multiplexer einsetzen: Ein TCA9548A teilt einen Bus in acht Zweige auf, von denen der Controller jeweils einen durchschaltet. So lassen sich auch acht gleiche Sensoren mit fester Adresse betreiben.

Geschwindigkeit und Reichweite

Die I²C-Spezifikation kennt mehrere Geschwindigkeitsklassen. Je schneller, desto strenger die Anforderungen an die Flanken:

Der Takt ist nicht die Nutzdatenrate. Jedes Byte braucht neun Takte (acht Bit plus ACK), dazu kommen Adressbytes, Registeradresse sowie Start und Stopp. Ein Beispiel: Der BME280 liefert seine Rohmesswerte in den acht Registern ab 0xF7. Der Lesezugriff besteht aus

• Schreibphase: Adressbyte und Registeradresse, 2 \cdot 9 = 18 Takte,

• Lesephase: Adressbyte und acht Datenbytes, 9 \cdot 9 = 81 Takte,

• Start, Repeated Start und Stopp, zusammen etwa 3 Takte.

t \approx \frac{102\ \text{Takte}}{100\ \mathrm{kHz}} = 1{,}02\ \mathrm{ms} \qquad \text{bzw.} \qquad \frac{102\ \text{Takte}}{400\ \mathrm{kHz}} \approx 0{,}26\ \mathrm{ms}

Von den 102 Takten tragen nur 8 \cdot 8 = 64 Nutzdaten, also rund 63 %. Für einen Wettersensor reicht das völlig; für Bilddaten oder schnelle Messreihen wird I²C zum Engpass – dafür gibt es SPI.

Reichweite: I²C ist für Leitungen auf einer Platine oder innerhalb eines Geräts gedacht. Die Grenze setzt nicht die Länge selbst, sondern die Buskapazität von höchstens 400 pF und die damit verbundene Anstiegszeit; dazu kommen Störungen, weil die hochohmigen Pull-ups Einstreuungen wenig entgegensetzen. Auf dem Steckbrett und mit kurzen Kabeln bis etwa einem Meter funktioniert I²C in der Regel bei 100 kHz problemlos. Für längere Strecken senkst Du den Takt, verwendest kleinere Pull-ups oder setzt Bus-Extender ein (z. B. P82B715, der den Bus mit höheren Strömen über Kabel treibt, oder PCA9615, der I²C differenziell überträgt).

Praxis: I²C an Arduino, ESP8266 und ESP32

In der Arduino-Welt heißt die I²C-Bibliothek Wire. Sie gehört bei allen drei Plattformen zum Lieferumfang und bietet dieselben Grundfunktionen, auch wenn die Hardware dahinter verschieden ist. Wo die Leitungen anzuschließen sind, zeigt das Tabset; Pinbelegungen einzelner Boards findest Du im Artikel zu den Pinouts von ESP8266 und ESP32.

ESP32 ESP8266 (nodeMCU) Arduino Uno all none

#include <Wire.h>

const int PIN_SDA = 21;
const int PIN_SCL = 22;

void setup() {
  Serial.begin(115200);
  Wire.begin(PIN_SDA, PIN_SCL);   // optional dritter Parameter: Takt, z. B. 400000
  Wire.setClock(400000);          // Fast Mode, wenn alle Teilnehmer ihn beherrschen
}

#include <Wire.h>

const int PIN_SDA = D2;   // GPIO4
const int PIN_SCL = D1;   // GPIO5

void setup() {
  Serial.begin(115200);
  Wire.begin(PIN_SDA, PIN_SCL);
  Wire.setClock(400000);  // Fast Mode, wenn alle Teilnehmer ihn beherrschen
}

#include <Wire.h>

void setup() {
  Serial.begin(115200);
  Wire.begin();           // Pins A4/A5 sind fest
  Wire.setClock(400000);  // Fast Mode, wenn alle Teilnehmer ihn beherrschen
}

Erster Test: der I²C-Scanner

Bevor Du eine Bibliothek für einen Baustein einbindest, prüfst Du, ob er am Bus überhaupt antwortet. Der Scanner nutzt das ACK-Bit: Er sendet an jede Adresse ein leeres Telegramm (Start, Adresse + W, Stopp) und wertet aus, ob ein Target mit ACK geantwortet hat. Wire.endTransmission() liefert dann 0; bei 2 kam auf die Adresse ein NACK. Die Initialisierung in setup() übernimmst Du aus dem Tabset oben.

void loop() {
  int anzahl = 0;
  Serial.println("Suche I2C-Teilnehmer ...");
  for (byte adresse = 0x08; adresse < 0x78; adresse++) {   // reservierte Adressen auslassen
    Wire.beginTransmission(adresse);
    byte ergebnis = Wire.endTransmission();               // 0 = ACK, 2 = NACK auf Adresse
    if (ergebnis == 0) {
      Serial.print("Teilnehmer gefunden: 0x");
      if (adresse < 0x10) Serial.print("0");
      Serial.println(adresse, HEX);
      anzahl++;
    }
  }
  Serial.print(anzahl);
  Serial.println(" Teilnehmer gefunden.");
  delay(5000);
}

Für die Wetterstation aus der Einleitung sollte der Scanner 0x20, 0x3C und 0x76 melden. Findet er nichts, hilft die Fehlersuche weiter.

Ein Register „von Hand“ lesen

Wie die Wire-Funktionen auf den Telegrammaufbau abbilden, zeigt das Lesen der Chip-ID des BME280. Jede Zeile entspricht einem Teil der Grafik aus dem Abschnitt Nachrichtenaufbau:

const byte BME280_ADRESSE = 0x76;   // 7-Bit-Adresse (SDO an GND)
const byte REG_CHIP_ID    = 0xD0;

byte leseRegister(byte adresse, byte reg) {
  Wire.beginTransmission(adresse);           // Start, Adresse + W
  Wire.write(reg);                           // Registeradresse
  Wire.endTransmission(false);               // false: kein Stopp, danach Repeated Start
  Wire.requestFrom(adresse, (byte)1);        // Adresse + R, 1 Byte lesen, NACK und Stopp
  return Wire.read();
}

// in setup() nach Wire.begin(...):
//   byte id = leseRegister(BME280_ADRESSE, REG_CHIP_ID);
//   Serial.println(id, HEX);   // 60 = BME280, 58 = BMP280

Das ist mehr als eine Fingerübung: BME280 und BMP280 sehen sich zum Verwechseln ähnlich, aber nur der BME280 misst die Luftfeuchte. Die Chip-ID verrät, welcher Chip auf dem Modul sitzt.

Eine Bibliothek verwenden

Im Alltag rechnest Du die Rohwerte nicht selbst um, sondern nutzt eine Bibliothek. Für den BME280 bietet sich z. B. die Adafruit BME280 Library an (über den Bibliotheksverwalter der Arduino-IDE, mit den Abhängigkeiten Adafruit Unified Sensor und Adafruit BusIO). Die Bibliothek erwartet standardmäßig die Adresse 0x77; bei Modulen mit SDO an GND übergibst Du 0x76:

#include <Wire.h>
#include <Adafruit_BME280.h>

Adafruit_BME280 bme;

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);                  // ESP32; ESP8266: Wire.begin(D2, D1); Uno: Wire.begin()
  if (!bme.begin(0x76, &Wire)) {
    Serial.println("BME280 nicht gefunden - Verdrahtung, Adresse und Chip-ID pruefen");
    while (true) delay(10);
  }
}

void loop() {
  Serial.print(bme.readTemperature());        Serial.print(" °C  ");
  Serial.print(bme.readHumidity());           Serial.print(" %  ");
  Serial.print(bme.readPressure() / 100.0F);  Serial.println(" hPa");
  delay(2000);
}

Ausführliche Anleitungen zu beiden Bausteinen der Wetterstation findest Du in den Artikeln zum BME280 und BMP280 und zum OLED-Display SSD1306.

Den Bus beobachten: Logic-Analyzer

Ob auf dem Bus wirklich das passiert, was der Code verspricht, zeigt ein Logic-Analyzer. Schon günstige 8-Kanal-Geräte zeichnen SDA und SCL auf; die Software PulseView enthält einen I²C-Dekoder, der Start, Adressen, R/W, ACK/NACK und Datenbytes direkt in die Messung schreibt. Wähle die Abtastrate deutlich höher als den Bustakt – mindestens das Vierfache, besser das Zehnfache (für 400 kHz also 2 bis 4 MHz) – und triggere auf die fallende Flanke von SDA. Wie die Messung eingerichtet wird, beschreibt der Artikel Digitale Signale mit PulseView und einem Logic-Analyzer untersuchen.

Checkliste: Bevor Du einen Sensor oder Aktor anschließt

Ein neues Modul ist schnell bestellt und verdrahtet. Damit es danach auch funktioniert – und nichts kaputtgeht –, prüfst Du vorher einige Punkte im Datenblatt des Bausteins bzw. Moduls und in der Dokumentation der Bibliothek.

Fehlersuche: Wenn der Bus schweigt

Die meisten Probleme mit I²C haben einfache Ursachen. Gehe von der Hardware zur Software vor: erst Versorgung und Verdrahtung, dann Pegel, dann Adresse und Bibliothek.

Leitfragen

1. Welche Leitungen hat ein I²C-Bus, und welche Kennzeichen unterscheiden ihn von anderen seriellen Schnittstellen? Antwort

I²C nutzt die Datenleitung SDA und die Taktleitung SCL, dazu eine gemeinsame Masse. Der Bus ist seriell, synchron (der Controller liefert den Takt) und halbduplex; die Teilnehmer werden über Adressen im Telegramm ausgewählt, und jedes Byte wird mit ACK bestätigt. Siehe Abschnitt „Steckbrief“

2. Warum braucht I²C Pull-up-Widerstände, und was bedeutet Wired-AND? Antwort

Alle Teilnehmer haben Open-Drain-Ausgänge, die eine Leitung nur nach Masse ziehen können; den HIGH-Pegel liefert allein der Pull-up-Widerstand. Die Leitung ist HIGH, wenn kein Teilnehmer zieht, und LOW, sobald einer zieht – eine UND-Verknüpfung durch die Verdrahtung, die Kurzschlüsse verhindert und Clock Stretching und Arbitrierung ermöglicht. Siehe Abschnitt „Leitungen und Potenziale“

3. Wie bemisst Du die Pull-up-Widerstände, und worauf achtest Du bei mehreren Modulen? Antwort

Die untere Grenze ergibt sich aus dem zulässigen Low-Strom, R_\mathrm{min} = (V_\mathrm{DD} - 0{,}4\ \mathrm{V}) / 3\ \mathrm{mA}, die obere aus Anstiegszeit und Buskapazität, R_\mathrm{max} = t_\mathrm{r} / (0{,}8473 \cdot C_\mathrm{b}). Die Pull-ups mehrerer Module liegen parallel und können zusammen die untere Grenze unterschreiten; überzählige Pull-ups entfernst Du dann. Siehe Abschnitt „Pull-up-Widerstände bemessen“

4. Wie ist ein I²C-Telegramm aufgebaut, mit dem der Controller ein Register eines Sensors liest? Antwort

Start, Adressbyte mit W, ACK, Registeradresse, ACK; dann Repeated Start, Adressbyte mit R, ACK, Datenbyte(s) vom Target, nach dem letzten Byte NACK des Controllers und Stopp. SDA ändert sich nur bei SCL LOW; Start und Stopp sind Flanken auf SDA bei SCL HIGH. Siehe Abschnitt „Nachrichtenaufbau“

5. Wie bestimmst Du das Adressbyte eines Bausteins, und was tust Du, wenn zwei Bausteine dieselbe Adresse haben? Antwort

Adressbyte = 2 · 7-Bit-Adresse + R/W, z. B. 0x76 → 0xEC (Schreiben) und 0xED (Lesen). Bei gleicher Adresse stellst Du zuerst einen Adresspin um; geht das nicht, nutzt Du einen zweiten I²C-Bus oder einen Multiplexer wie den TCA9548A. Siehe Abschnitt „Adressen und Adresskonflikte“

6. Welche Taktraten sind bei I²C üblich, und was begrenzt Geschwindigkeit und Leitungslänge? Antwort

Üblich sind 100 kHz (Standard Mode) und 400 kHz (Fast Mode), seltener 1 MHz (Fast Mode Plus). Jedes Byte braucht neun Takte, dazu kommen Adressen und Steuerbedingungen. Die Buskapazität (höchstens 400 pF) bestimmt mit den Pull-ups die Anstiegszeit und begrenzt damit Takt und Leitungslänge. Siehe Abschnitt „Geschwindigkeit und Reichweite“

7. Was prüfst Du, bevor Du einen I²C-Sensor an einen Mikrocontroller anschließt? Antwort

Im Datenblatt: Schnittstelle und Pinbezeichnung, freie Adresse und Pull-ups am Bus, Versorgungsspannung und Strombedarf, Logikpegel, höchster Takt und Umgebungsbedingungen. In der Bibliotheksdokumentation: passende Bibliothek für MCU und Anwendung, Speicherbedarf (auch Laufzeitpuffer) und vorhandene Beispiele oder Testprogramme. Siehe Abschnitt „Checkliste“

8. Wie gehst Du vor, wenn der I²C-Scanner keinen Teilnehmer findet? Antwort

Von der Hardware zur Software: Versorgung am Modul messen, Verdrahtung und Pinzuordnung in Wire.begin() prüfen (SDA/SCL vertauscht, gespiegelte Stiftleiste), Ruhepegel HIGH auf beiden Leitungen kontrollieren (Pull-ups vorhanden?), dann Adresse und Chip-ID. Ein Logic-Analyzer zeigt, ob Telegramme gesendet und bestätigt werden. Siehe Abschnitt „Fehlersuche“

Links und weitere Informationen

• als Nachschlagewerk: NXP: UM10204 – I²C-bus specification and user manual (Rev. 7)

• NXP: AN10441 – Level shifting techniques in I²C-bus design

• Arduino-Referenz: Wire-Bibliothek

• Espressif: I²C-API des Arduino-Kerns für den ESP32

• ESP8266-Arduino-Kern: Bibliotheken (Wire, SPI)

• Bosch Sensortec: BME280 – Produktseite mit Datenblatt

• oer-informatik.de: BME280 und BMP280 am ESP anschließen

• oer-informatik.de: OLED-Display SSD1306 anbinden

• oer-informatik.de: Digitale Signale mit PulseView und einem Logic-Analyzer untersuchen

• oer-informatik.de: Pinouts von ESP8266 und ESP32

• oer-informatik.de: Schnittstellen und Datenübertragung – Wiederholung und Übungsaufgaben

• Wikipedia: I²C

Hinweis zur Nachnutzung als Open Educational Resource (OER)

Dieser Artikel und seine Texte, Bilder, Grafiken, Code und sonstiger Inhalt sind - sofern nicht anders angegeben - lizenziert unter CC BY 4.0. Nennung gemäß TULLU-Regel bitte wie folgt: “I²C: Ein Bus, zwei Leitungen, viele Sensoren” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/i2c-bus veröffentlicht, die Quelltexte sind in weiterverarbeitbarer Form verfügbar im Repository unter https://gitlab.com/oer-informatik/mcu/mcu-schnittstellen. Erstellt mit KI-Assistenz; von mir umfassend redaktionell überarbeitet, geprüft und freigegeben. Stand: 03.11.2026.

[Kommentare zum Artikel lesen, schreiben] / [Artikel teilen] / [gitlab-Issue zum Artikel schreiben]