Den Pro Mini als I2C-Slave für den Raspberry Pi nutzen

Wer Sensorik, Aktorik oder eigene Logik möglichst kompakt und stromsparend auslagern möchte, kann den Pro Mini als I2C-Slave für den Raspberry Pi nutzen und damit den Linux-Rechner elegant entlasten. Der Raspberry Pi übernimmt dann als I2C-Master die übergeordnete Steuerung (z. B. Datenlogging, Netzwerk, Home-Assistant-Integration), während ein Arduino Pro Mini als Slave zeitkritische Aufgaben erledigt: Impulse zählen, Relais schalten, ADC-Messungen durchführen oder mehrere Sensoren vorverarbeiten. Das ist besonders praktisch, wenn Sie am Pi zwar viele GPIOs hätten, aber nicht jede Aufgabe in Python oder unter Linux mit präzisem Timing lösen möchten. Entscheidend ist jedoch, dass der I2C-Bus elektrisch korrekt aufgebaut ist: Der Raspberry Pi arbeitet auf 3,3 V-Logik und ist an den GPIOs nicht 5 V-tolerant. Viele Pro-Mini-Varianten laufen hingegen mit 5 V (16 MHz). Wer hier falsch verkabelt, riskiert nicht nur Kommunikationsprobleme, sondern im Worst Case Schäden am Pi. In diesem Leitfaden erfahren Sie, welche Pro-Mini-Variante sich eignet, wie die Verdrahtung inklusive Pull-ups und Pegelanpassung funktioniert, wie Sie Slave-Adresse und Datenformat definieren und wie Sie typische Fehler wie Bus-Hänger, Adresskonflikte oder instabile Übertragungen sicher beheben.

Warum ein Pro Mini als I2C-Slave am Raspberry Pi sinnvoll ist

Die Kombination aus Raspberry Pi (Master) und Pro Mini (Slave) verbindet zwei Welten: Linux-Komfort und Mikrocontroller-Determinismus. Typische Vorteile in der Praxis:

• Entlastung des Raspberry Pi: Zeitkritische Aufgaben (PWM, Pulse, Debouncing, Sampling) laufen auf dem Mikrocontroller.
• Saubere Schnittstelle: I2C braucht nur SDA, SCL und GND (plus Versorgung), ideal für kompakte Aufbauten.
• Skalierbarkeit: Mehrere Slaves am selben Bus sind möglich, solange die Adressen eindeutig sind.
• Robustheit: Der Pro Mini kann bei Bedarf auch unabhängig arbeiten und nur Statusdaten liefern.
• Stromsparoptionen: Besonders der 3,3 V/8 MHz Pro Mini eignet sich für Low-Power-Designs.

Grundprinzip: Wer ist Master, wer ist Slave?

Am I2C-Bus initiiert der Master die Kommunikation: Er setzt START, sendet eine 7-Bit-Adresse plus R/W-Bit und taktet die Übertragung über SCL. Der Slave reagiert auf „seine“ Adresse, bestätigt mit ACK und sendet oder empfängt Daten. In diesem Setup ist der Raspberry Pi praktisch immer Master, der Pro Mini ist Slave. Der Pi fragt zyklisch Werte ab oder übergibt Kommandos, während der Pro Mini eine kleine Register-Logik bereitstellt (ähnlich wie ein Sensor-IC).

Für einen technischen Hintergrund zum Busverhalten und zu Buszuständen ist die I2C-Referenz von NXP eine verlässliche Grundlage: I2C-bus specification and user manual (UM10204).

Die wichtigste Frage: 3,3 V vs. 5 V – so schützen Sie den Raspberry Pi

Der Raspberry Pi nutzt 3,3 V-Logikpegel an den GPIOs. Ein 5 V-Pro-Mini kann auf SDA/SCL Signale mit 5 V-Pegel ziehen, wenn Pull-ups oder interne Schaltungen ungünstig ausgelegt sind. Daher sollten Sie eine der folgenden Strategien wählen:

• Empfohlen: Pro Mini 3,3 V / 8 MHz verwenden und den gesamten I2C-Bus auf 3,3 V betreiben.
• Alternativ: 5 V Pro Mini / 16 MHz verwenden, aber SDA/SCL sauber per bidirektionalem Level-Shifter anpassen.
• Nicht empfehlenswert: „Direkt anschließen und hoffen“, insbesondere wenn auf dem Pro Mini Pull-ups auf 5 V liegen.

Offizielle Hinweise zur Aktivierung und Nutzung von I2C am Raspberry Pi finden Sie in der Raspberry-Pi-Dokumentation: Raspberry Pi Konfiguration (I2C aktivieren).

Pull-ups richtig dimensionieren: Der Bus lebt von sauberen Flanken

I2C arbeitet mit Open-Drain: SDA und SCL werden nicht aktiv „High“ getrieben, sondern über Pull-up-Widerstände hochgezogen. Zu starke Pull-ups (sehr kleiner Widerstand) erhöhen den Strom und können Treiber überlasten, zu schwache Pull-ups (sehr großer Widerstand) machen Flanken zu langsam. Besonders häufig ist der Fehler, dass mehrere Module jeweils eigene Pull-ups mitbringen, die dann parallel wirken.

Der Ersatzwiderstand mehrerer Pull-ups in Parallelschaltung ergibt sich aus:

$\frac{1}{R\_\mathrm{gesamt}}=\frac{1}{R\_1}+\frac{1}{R\_2}+\cdots$

Praxisregel: Wenn der Pi und ein Modul bereits Pull-ups haben, sollten Sie vermeiden, weitere Pull-ups „blind“ hinzuzufügen. Prüfen Sie die Module (Lötjumper) und lassen Sie im Zweifel nur einen Satz Pull-ups aktiv, der auf 3,3 V referenziert ist.

Verdrahtung: SDA, SCL, GND und Versorgung

Für eine stabile Verbindung benötigen Sie eine gemeinsame Masse (GND) und die beiden Signalleitungen. Zusätzlich versorgen Sie den Pro Mini über einen passenden Spannungsanschluss (abhängig von Pro-Mini-Variante und Aufbau).

• GND: Raspberry Pi GND ↔ Pro Mini GND (zwingend erforderlich)
• SDA: Raspberry Pi SDA (GPIO2) ↔ Pro Mini SDA (ATmega328P: A4)
• SCL: Raspberry Pi SCL (GPIO3) ↔ Pro Mini SCL (ATmega328P: A5)
• Versorgung: Pro Mini 3,3 V idealerweise direkt aus 3,3 V (wenn Gesamtstrom gering) oder über einen geeigneten Regler aus 5 V

Wenn Sie unsicher sind, welche Pins Arduino-seitig für I2C genutzt werden, ist die Wire-Referenz hilfreich: Arduino Wire Library (I2C) Referenz.

Level-Shifter richtig einsetzen (falls 5 V Pro Mini)

Wenn Sie einen 5 V Pro Mini einsetzen müssen, verwenden Sie einen bidirektionalen I2C-Level-Shifter. Wichtig ist dabei:

• Low-Voltage-Seite: an 3,3 V (Pi) mit Pull-ups auf 3,3 V
• High-Voltage-Seite: an 5 V (Pro Mini) mit Pull-ups auf 5 V (oder auf der Modulplatine vorhandene Pull-ups)
• Gemeinsame Masse: muss durchverbunden sein
• Takt reduzieren: bei langen Leitungen oder vielen Teilnehmern zunächst 100 kHz statt 400 kHz testen

Adresse festlegen: Pro Mini als Slave eindeutig adressieren

Damit der Raspberry Pi den Pro Mini anspricht, brauchen Sie eine 7-Bit-I2C-Adresse, die nicht mit anderen Geräten kollidiert. Typisch sind Werte im Bereich 0x08 bis 0x77 (einige Bereiche sind reserviert oder unüblich). Sinnvoll ist eine feste Projektkonvention, z. B. Pro-Mini-Slaves im Bereich 0x20–0x2F. Vermeiden Sie Adressen, die bereits durch Sensoren häufig genutzt werden.

• Beispieladresse: 0x12 oder 0x24 (beliebig, solange frei)
• Mehrere Slaves: Jeder Pro Mini benötigt eine eigene Adresse
• Konfliktvermeidung: Vorab mit I2C-Scan am Pi prüfen

I2C am Raspberry Pi aktivieren und Bus prüfen

Bevor der Pro Mini ins Spiel kommt, sollte der I2C-Bus am Raspberry Pi sauber laufen. Aktivieren Sie I2C in der Systemkonfiguration und prüfen Sie danach, ob das Interface vorhanden ist. Für die Diagnose sind die Linux-Tools aus dem Paket i2c-tools üblich; der klassische Scan erfolgt mit einem Tool, das alle Adressen abfragt. Hintergrund, Installation und Nutzung finden Sie kompakt in vielen Linux-Howtos; als Einstieg ist die manpage-basierte Beschreibung der Tools hilfreich: i2cdetect manpage.

Ein typisches Vorgehen (ohne Codeblock) ist: i2c-tools installieren, dann den Bus scannen und prüfen, ob nur erwartete Geräteadressen auftauchen. Wenn bereits Sensoren angeschlossen sind, notieren Sie deren Adressen – so erkennen Sie sofort, ob der Pro Mini eine freie Adresse benötigt oder ein Konflikt besteht.

Kommunikationsdesign: Datenformat und „Register“-Konzept

Damit die Kommunikation wartbar bleibt, lohnt sich ein klarer Aufbau. Bewährt hat sich ein registerähnliches Protokoll: Der Raspberry Pi schreibt zuerst eine Register-ID (z. B. 0x01 für Temperatur, 0x02 für Zählerstand), anschließend liest er eine definierte Anzahl Bytes. Der Pro Mini merkt sich das zuletzt angeforderte Register und liefert beim nächsten Read die passenden Daten.

• Register 0x00: Geräte-ID / Version
• Register 0x01: Messwert A (z. B. ADC, 2 Bytes)
• Register 0x02: Messwert B (z. B. Impulse, 4 Bytes)
• Register 0x10: Steuerflags (z. B. Relais an/aus)
• Register 0x11: Statusflags / Fehlercodes

Wichtig ist, die Byte-Reihenfolge (Endianness) und Skalierung eindeutig zu definieren, damit auf dem Pi keine „Zahlenmystik“ entsteht. Wenn Sie z. B. Spannungen übertragen, ist eine feste Skalierung (Millivolt als Integer) oft robuster als Float-Werte.

Skalierung von Messwerten: Float vermeiden, Integer bevorzugen

Wenn der Pro Mini eine Spannung misst und Sie diese als Millivolt übertragen wollen, ist das Protokoll stabiler. Beispiel: 3,287 V wird als 3287 übertragen. Die Umrechnung ist klar und leicht nachvollziehbar:

$U\_\mathrm{mV}=U\_V\cdot 1000$

Auf dem Raspberry Pi können Sie diese Integerwerte später bei Bedarf wieder in Volt umrechnen, ohne Rundungsfehler in der Übertragung zu riskieren.

Arduino-Seite: Was der Pro Mini als I2C-Slave leisten muss

Auf dem Pro Mini wird der I2C-Slave in der Regel über die Wire-Library umgesetzt. Konzeptuell benötigt der Slave zwei Arten von Ereignissen: Er muss auf empfangene Daten reagieren (z. B. Register auswählen oder Kommandos annehmen) und er muss Daten bereitstellen, wenn der Master liest. Wichtig ist dabei, dass der Slave-Handler schnell bleibt: Lange Berechnungen oder Serial-Ausgaben im I2C-Kontext können zu Timingproblemen führen.

• Empfang (Write vom Pi): Register-ID speichern, Kommandos übernehmen, ggf. Parameter einlesen
• Senden (Read vom Pi): vorbereiteten Puffer ausgeben (z. B. 2–16 Bytes)
• Keine Blockaden: Keine Delays, keine langen Schleifen in den I2C-Callbacks
• Threading-Denken: Werte im Hauptloop aktualisieren, im Callback nur kopieren/senden

Raspberry-Pi-Seite: Lesen und Schreiben per SMBus/I2C

Auf dem Raspberry Pi sind zwei typische Wege verbreitet: Entweder Sie nutzen eine I2C/SMBus-Library in Python (sehr bequem für Prototyping), oder Sie arbeiten in C/C++ direkt über /dev/i2c-* und ioctl-Aufrufe. Für die meisten Maker-Projekte ist Python mit smbus2 oder ähnlichen Bibliotheken ausreichend, solange die Datenraten moderat sind und das Protokoll gut definiert ist.

• Write: Register auswählen oder Kommando senden
• Read: feste Byteanzahl lesen und interpretieren
• Retry-Strategie: bei NACK/IOError kurz erneut versuchen (robuster bei langen Leitungen)

Typische Stolpersteine und wie Sie sie sauber lösen

Viele „I2C-Probleme“ sind nicht das Protokoll, sondern Elektrik, Pull-ups oder Timing. Die häufigsten Fehlerbilder lassen sich mit systematischer Diagnose schnell beheben.

Problem: Der Pro Mini erscheint nicht im I2C-Scan

• Adresse falsch: Prüfen, ob der Slave wirklich auf der erwarteten 7-Bit-Adresse läuft.
• Verdrahtung: SDA/SCL vertauscht oder fehlender gemeinsamer GND.
• Pegelproblem: 5 V-Pull-ups am Bus, obwohl der Pi 3,3 V erwartet.
• Pull-ups fehlen: Ohne Pull-ups bleibt der Bus undefiniert; manche Setups funktionieren „zufällig“ nie.

Problem: Bus hängt (SDA oder SCL dauerhaft low)

• Brownout am Pro Mini: Versorgung instabil, der Slave bleibt in einem schlechten Zustand und hält SDA low.
• Level-Shifter-Inkompatibilität: Manche Shifter reagieren empfindlich auf bestimmte Buszustände.
• Recovery: Bus-Recovery implementieren oder Neustart der betroffenen Seite; im Design auf stabile Versorgung und kurze Leitungen achten.

Problem: Daten sind inkonsistent oder „springen“

• Race Condition: Werte werden während des Sendens aktualisiert; Lösung: Pufferkopie verwenden.
• Byte-Reihenfolge: Endianness nicht klar definiert; Lösung: im Protokoll festlegen.
• Zu hohe Busgeschwindigkeit: Bei langen Leitungen oder vielen Teilnehmern auf 100 kHz reduzieren.

Performance und Grenzen: Wie viel Datenverkehr ist realistisch?

I2C ist kein Hochgeschwindigkeitsbus, aber für Steuer- und Messdaten ideal. In einem typischen Setup (100 kHz bis 400 kHz, wenige Bytes pro Abfrage) sind mehrere Slaves problemlos. Kritisch wird es bei sehr häufigen Abfragen, langen Leitungen oder wenn der Pro Mini in den I2C-Callbacks zu viel Arbeit verrichtet. Ein sauberer Ansatz ist, Messwerte im Hauptloop zu aktualisieren und im I2C-Handler nur Bytepuffer auszugeben.

Robustes Design: Empfehlungen für ein „produktionstaugliches“ Setup

• 3,3 V Pro Mini bevorzugen: reduziert Pegelrisiken und spart oft Strom.
• Pull-ups bewusst planen: nicht zufällig durch mehrere Module parallel „zu stark“ machen.
• Protokoll versionieren: Register 0x00 als Versionsbyte hilft bei späteren Updates.
• Fehlercodes definieren: Statusregister mit Flags für Sensorfehler, Überlauf, Timeout.
• Watchdog/Resets: bei kritischen Anwendungen den Slave so auslegen, dass er sich aus Hängern befreien kann.

Outbound-Links: Verlässliche Quellen für Setup, Spezifikation und Diagnose

• Arduino Wire Library: I2C auf Arduino/Pro Mini korrekt nutzen
• Raspberry Pi Dokumentation: I2C aktivieren und Schnittstellen konfigurieren
• NXP UM10204: Offizielle I2C-Spezifikation, Buszustände, Timing-Grundlagen
• i2cdetect manpage: I2C-Scan und Diagnose unter Linux
• Raspberry Pi Hardware-Dokumentation: GPIO- und Pegelhinweise (3,3 V)

IoT-PCB-Design, Mikrocontroller-Programmierung & Firmware-Entwicklung

PCB Design • Arduino • Embedded Systems • Firmware

Ich biete professionelle Entwicklung von IoT-Hardware, einschließlich PCB-Design, Arduino- und Mikrocontroller-Programmierung sowie Firmware-Entwicklung. Die Lösungen werden zuverlässig, effizient und anwendungsorientiert umgesetzt – von der Konzeptphase bis zum funktionsfähigen Prototyp.

Diese Dienstleistung richtet sich an Unternehmen, Start-ups, Entwickler und Produktteams, die maßgeschneiderte Embedded- und IoT-Lösungen benötigen. Finden Sie mich auf Fiverr.

Leistungsumfang:

• IoT-PCB-Design & Schaltplanerstellung

• Leiterplattenlayout (mehrlagig, produktionstauglich)

• Arduino- & Mikrocontroller-Programmierung (z. B. ESP32, STM32, ATmega)

• Firmware-Entwicklung für Embedded Systems

• Sensor- & Aktor-Integration

• Kommunikation: Wi-Fi, Bluetooth, MQTT, I²C, SPI, UART

• Optimierung für Leistung, Stabilität & Energieeffizienz

Lieferumfang:

• Schaltpläne & PCB-Layouts

• Gerber- & Produktionsdaten

• Quellcode & Firmware

• Dokumentation & Support zur Integration

Arbeitsweise:Strukturiert • Zuverlässig • Hardware-nah • Produktorientiert

CTA:
Planen Sie ein IoT- oder Embedded-System-Projekt?
Kontaktieren Sie mich gerne für eine technische Abstimmung oder ein unverbindliches Angebot. Finden Sie mich auf Fiverr.