I²C-Bus richtig beschalten

Temperatursensor, Display, Uhrenbaustein, Port-Erweiterung: Viele Bausteine sprechen I²C. Zwei Leitungen genügen für Dutzende Teilnehmer, jeder hat seine eigene Adresse. Damit das funktioniert, braucht der Bus zwei Widerstände, die erstaunlich oft falsch sind: zu groß, zu klein, doppelt oder gar nicht vorhanden. Der Bus läuft dann manchmal, manchmal nicht, und der Fehler ist schwer zu finden.

Hier beschaltest du einen Bus mit einem ESP32, einem Umweltsensor BME280 und einem OLED-Display mit SSD1306 bei 400 kHz, und du rechnest die Pull-ups aus statt sie zu raten. Was beim Arduino Uno anders ist, steht weiter unten.

Schaltplan

• U1, ESP32-WROOM-32E: der Controller (Master). In Arduino liegen SDA und SCL vorgegeben auf GPIO 21 und 22, das sind die Pins 33 und 36 des Moduls.
• SDA, SCL: Datenleitung und Taktleitung. Alle Teilnehmer hängen parallel daran.
• R1, R2, 2,2 kΩ: die Pull-up-Widerstände, je einer pro Leitung und Bus, nicht pro Teilnehmer.
• U2, BME280: Sensor für Temperatur, Feuchte und Luftdruck, Adresse 0x76 (mit SDO an 3,3 V: 0x77).
• U3, SSD1306: Controller eines kleinen OLED-Displays, Adresse 0x3C.
• Versorgung: Alle Teilnehmer an 3,3 V und an derselben Masse.

So funktioniert die Schaltung

Kein Teilnehmer treibt eine I²C-Leitung jemals aktiv auf High. Jeder Ausgang ist ein Transistor nach Masse, ein sogenannter Open-Drain-Ausgang (Open-Collector-Ausgang). Er kann die Leitung nur auf Low ziehen oder loslassen. Lassen alle los, holt der Pull-up die Leitung auf High.

Das hat zwei Vorteile. Ziehen zwei Teilnehmer gleichzeitig in verschiedene Richtungen, gibt es keinen Kurzschluss: Low gewinnt einfach. Darauf beruhen die Bestätigung jedes Bytes (ACK) und das „Clock Stretching“, mit dem ein langsamer Slave den Takt anhält. Und der Pull-up bestimmt den High-Pegel; Teilnehmer mit verschiedenen Versorgungen lassen sich so leichter verbinden.

Der Preis ist die Geschwindigkeit. Die fallende Flanke ist schnell, denn ein Transistor zieht kräftig. Die steigende Flanke dagegen macht der Pull-up allein: Er muss die Kapazität aller Pins und Leitungen umladen, wie bei einem RC-Glied. Ein großer Widerstand macht die Flanke langsam, ein kleiner belastet die Ausgänge. Dazwischen liegt der richtige Wert.

Dimensionierung

Die Grenzen stehen in der I²C-Spezifikation. Für den Fast Mode mit 400 kHz: Anstiegszeit t_r höchstens 300 ns, Buskapazität höchstens 400 pF, und ein Ausgang muss bei 0,4 V Restspannung 3 mA aufnehmen können. Im Standard Mode mit 100 kHz sind 1000 ns erlaubt.

1. Buskapazität schätzen. Jeder Pin bringt bis zu 10 pF mit, eine Leitung auf Platine oder im Flachkabel etwa 50 bis 100 pF pro Meter. Drei Teilnehmer mit 30 cm Kabel und Leiterbahnen: rund 30 pF + 30 pF + Reserve, gerechnet wird mit C_b = 100 pF.

2. Kleinster Widerstand. Der Ausgang muss den Strom durch den Pull-up gegen Masse ziehen können:

3. Größter Widerstand. Von 30 auf 70 % braucht ein RC-Glied τ · ln(0,7 / 0,3) ≈ 0,847 τ:

4. Wählen und prüfen. Zwischen 0,97 und 3,5 kΩ liegt 2,2 kΩ aus der E12-Reihe gut in der Mitte. Die Anstiegszeit wird 0,8473 · 2,2 kΩ · 100 pF ≈ 186 ns, der Strom bei Low 3,3 V / 2,2 kΩ = 1,5 mA. Bei 100 kHz dürftest du bis 11,8 kΩ gehen; 4,7 kΩ ist dort der übliche Wert.

5. Module mit eigenen Pull-ups. Fast jede Breakout-Platine bringt schon Pull-ups mit, oft 10 kΩ oder 4,7 kΩ. Sie liegen parallel zu deinen. Mit zwei Modulen à 10 kΩ und R1 = 2,2 kΩ:

Das liegt noch über R_min. Bei fünf solchen Modulen wären es 0,92 kΩ – zu klein. Dann entfernst du die Pull-ups auf den Modulen (meist über eine Lötbrücke) oder lässt R1 und R2 weg.

Code

Der Scanner fragt alle Adressen ab und listet, wer antwortet – der erste Test für jeden neuen Bus:

#include <Wire.h>

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);          // ESP32: SDA, SCL; am Uno einfach Wire.begin()
  Wire.setClock(400000);       // 400 kHz
  for (byte adr = 1; adr < 127; adr++) {
    Wire.beginTransmission(adr);
    if (Wire.endTransmission() == 0) {
      Serial.print("Gefunden: 0x");
      Serial.println(adr, HEX);
    }
  }
}

void loop() {}

Für diesen Bus meldet er 0x3C und 0x76. Fehlt ein Teilnehmer, stimmen Adresse, Versorgung oder Verdrahtung nicht.

Bauteilliste

Varianten

Arduino Uno. SDA liegt auf A4 (PC4, Pin 27), SCL auf A5 (PC5, Pin 28). Die Bibliothek Wire schaltet die internen Pull-ups von 20 bis 50 kΩ ein. Für kurze Leitungen bei 100 kHz reicht das gerade, für alles andere nicht. Rechne an 5 V mit R_min = (5 V − 0,4 V) / 3 mA ≈ 1,5 kΩ; üblich sind 4,7 kΩ.

3,3-V-Sensor am 5-V-Arduino. Hängen die Pull-ups an 5 V, sieht der Sensor 5 V an seinen Pins; viele vertragen das nicht. Hängen sie an 3,3 V, erkennt der ATmega328P High erst ab 0,6 · 5 V = 3,0 V – das reicht knapp, solange die internen Pull-ups nach 5 V nicht dagegen arbeiten. Sauber ist ein bidirektionaler Pegelwandler mit zwei MOSFETs. Viele Module haben ihn schon eingebaut.

Lange Leitungen. Über etwa einen Meter wird die Kapazität zum Problem. Abhilfe schaffen ein langsamerer Takt, Bus-Extender wie der P82B715 oder der PCA9615 mit differenzieller Übertragung. Kleine Serienwiderstände von 33 bis 100 Ω an jedem Teilnehmer dämpfen Überschwinger.

Gleiche Adressen. Zwei identische Sensoren mit fester Adresse trennt ein I²C-Multiplexer wie der TCA9548A in eigene Teilbusse.

Typische Fehler

• Scanner findet nichts, Bus hängt: Pull-ups fehlen, SDA und SCL vertauscht oder keine gemeinsame Masse.
• Funktioniert bei 100 kHz, nicht bei 400 kHz: Pull-ups zu groß oder Leitung zu lang. Mit dem Oszilloskop die Flanken ansehen: Statt Rechtecken siehst du Haifischflossen.
• Low-Pegel zu hoch: Zu viele parallele Pull-ups auf den Modulen. Gesamtwiderstand nachmessen, mit dem Multimeter zwischen SDA und 3,3 V bei stromlosem Aufbau.
• ESP32 stürzt ab oder ein Pin ist tot: Pull-ups an 5 V. Die Pins des ESP32 vertragen höchstens 3,6 V.
• Ein Teilnehmer fehlt sporadisch: Adresskonflikt oder ein Slave hat beim Reset mitten in einer Übertragung SDA auf Low festgehalten. Neun Takte auf SCL befreien den Bus.

Selbsttest