ESP32-Schnittstellen – Wer darf gerade reden?

Welche ESP32 Schnittstellen gibt es, und wann nimmst du UART, I²C, SPI, 1-Wire, RS-485, CAN oder I²S? Ich vergleiche den ESP8266 mit dem ESP32, erkläre jedes Protokoll mit Signalverlauf und Code und zeige, wie du die Pins für dein Projekt verteilst.

(Lesedauer: ca. 30 Minuten)

Wer schon einmal einer Funkrunde zugehört hat, kennt die Spielregel: Einer redet, alle anderen hören zu, und am Ende wird übergeben. Drücken zwei gleichzeitig die Sendetaste, hört keiner mehr etwas außer Pfeifen und Gebrummel. Ein Mikrocontroller, an dem fünf Sensoren, ein Display und ein Funkmodul hängen, hat genau dasselbe Problem. Auch dort lautet die wichtigste Frage: Wer darf gerade reden?

Bei mir lag lange ein ESP8266 auf der Werkbank. Inzwischen geistert ein Projekt mit dem ESP32 durch meinen Kopf, ein selbst gebauter Antennenrotor, der Satelliten und die ISS verfolgt. Bevor ich dafür den ersten Draht anlöte, wollte ich wissen, welche Schnittstellen der ESP32 eigentlich mitbringt und wann man welche nimmt. UART, I²C und SPI habe ich schon selbst verdrahtet. 1-Wire, I²S, RS-485 mit Modbus und CAN sind für mich dagegen Neuland, da erkundet der Universaldilettant also mit dir zusammen.

Wir fangen mit dem Vergleich zwischen ESP8266 und ESP32 an und klären dann, wie Bits überhaupt durch einen Draht kommen. Danach arbeiten wir uns von den kurzen Sensorbussen auf dem Steckbrett über die robusten Feldbusse aus der Industrie bis zu Audio und Analogsignalen vor. Zum Schluss geht es darum, welches Protokoll wofür taugt und wie du die Pins verteilst, ohne dass der ESP32 beim Booten bockt.

Wer gezielt springen will:

1. ESP8266 und ESP32 im Vergleich

Erinnerst du dich an die Anfangszeit des IoT-Booms? Man bestellte für drei Euro fünfzig einen kleinen blauen ESP8266 aus Fernost, rang zwei Nächte mit dem störrischen USB-Seriell-Treiber und fühlte sich wie ein Halbgott, als die erste WLAN-Steckdose die Schreibtischlampe schaltete. Die Euphorie hielt genau so lange, bis man mehr als ein Sensörchen per Kabel anschließen wollte: „Wo stecke ich jetzt das zweite I²C-Display, das GPS-Modul und die Speicherkarte an, ohne dass mein Code wie eine Diashow ruckelt?“

Hier kommt der ESP32 ins Spiel, der große Bruder mit zwei Prozessorkernen, Bluetooth und vor allem einem Sack voll echter Hardware-Peripherie. Bevor wir uns ganz dem ESP32 widmen, stellen wir die beiden nebeneinander und schauen, warum der ESP8266 bei drahtgebundenen Bussen in Rente gehen darf.

1.1. Die Hardware im Überblick

Wir vergleichen den Urvater ESP8266 (meist als ESP-12E/NodeMCU-Modul) mit dem klassischen ESP32 (ESP32-WROOM-32 bzw. Chip-Variante ESP32-D0WD).

Schnittstelle ESP8266 ESP32 (klassisch)
CPU Tensilica L106 (Single Core) Xtensa LX6 (Dual Core)
UART 2 (UART0 voll, UART1 nur TX) 3 vollwertige Controller (UART0–2)
I²C 1 (rein softwarebasiert / Bit-Banging) 2 eigenständige Hardware-Controller
SPI 2 (SPI und HSPI) 4 Controller-Interfaces (SPI0–3)
I²S (Audio) 1 (Ein-/Ausgabe) 2 eigenständige Controller
CAN / TWAI Nein Ja (integrierter TWAI-Controller, Espressifs Name für CAN; ISO 11898-1)
Ethernet-MAC Nein Ja (integriert, 10/100 Mbit/s, mit DMA und IEEE 1588 zur Zeitsynchronisation)
SDIO / SD-MMC (Speicherkarten-Schnittstelle) Nur Slave-Modus Host und Slave (nativer 1-Bit-/4-Bit-Zugriff auf SD-Karten)
1-Wire per GPIO (Bit-Banging) per RMT- oder UART-Hardware (kein eigener 1-Wire-Controller)

Beim ESP8266 war der Platz auf dem Silizium knapp. Es gab gerade so viel Hardware, dass ein Grundsystem lief, und für alles Weitere galt: „Das rechnet die CPU schon irgendwie in Software aus.“ Diese Nachbildung einer Schnittstelle in Software heißt Bit-Banging (Abschnitt 1.2.2).

Beim ESP32 hat Espressif die Spendierhosen angezogen. Eigene Hardware-Blöcke erledigen die Protokollarbeit im Hintergrund, und dank DMA (Direct Memory Access, Abschnitt 5.1.3) muss der Prozessor nicht bei jedem Taktimpuls Däumchen drehen.

1.2. Hardware-Controller statt Bit-Banging

Was bedeuten diese Unterschiede auf dem Steckbrett und im Code? Schauen wir uns die kleinen seelischen Narben an, die der ESP8266 bei seinen Besitzern hinterlassen hat.

1.2.1. UART: Das Elend mit dem halben Kanal

Auf dem Papier hat der ESP8266 zwei serielle Schnittstellen, UART0 und UART1. In der Praxis hängt UART0 (TX/RX) fest am USB-Seriell-Wandler (per Serial.swap() lässt er sich auf GPIO 15/13 umlegen, dann fehlt aber die USB-Konsole). Wer dort per Serial.print("Debug-Müll") seine Variablen beobachtet, kann nicht gleichzeitig saubere Binärdaten von einem GPS-Modul empfangen. UART1 ist ein Treppenwitz der Mikrocontroller-Geschichte: Er hat nur einen TX-Pin, weil der RX-Pin intern schon verplant ist. Man kann der Außenwelt also etwas zurufen, bleibt aber taub wie eine Nuss. Ein Modbus-Gerät, das antworten möchte, hat da schlechte Karten.

Der ESP32 hat drei vollwertige Hardware-UARTs (UART0, UART1, UART2), alle mit RX und TX. Dank der GPIO-Matrix lassen sich die Pins frei wählen (Abschnitt 2.3.2). Dazu kommen Hardware-Flusskontrolle (RTS/CTS) und eine eingebaute Umschaltlogik für RS-485-Transceiver (Abschnitt 4.1.2).

1.2.2. I²C: Hardware statt Software

Bei I²C ist der Unterschied am größten. Der ESP8266 hat keinen Hardware-I²C-Controller. Jeden Taktimpuls auf SCL und jedes Bit auf SDA muss die CPU per Software aus den Pins prügeln, eben Bit-Banging. Funkt in diesem Moment ein WLAN-Interrupt dazwischen, was bei einem WLAN-Chip gelegentlich vorkommen soll, verzieht sich das Timing, und die Sensorwerte werden zu digitalem Rauschen.

Der ESP32 bringt zwei unabhängige Hardware-I²C-Controller mit, also zwei getrennte Busse. Das löst einen Klassiker: zwei Displays mit derselben fest verdrahteten Adresse 0x3C. Beim ESP8266 schlägt man resigniert den Kopf auf die Werkbank oder lötet einen Multiplexer ein. Beim ESP32 hängt ein Display an Bus 0 und das andere an Bus 1. Start, Stopp und ACK erledigt die Hardware, die CPU kümmert sich derweil um anderes.

1.2.3. SPI und I²S

Beim SPI stößt der ESP8266 mit zwei Schnittstellen, von denen eine meist am internen Flash hängt, schnell an seine Grenzen. Der ESP32 hat vier SPI-Controller, zwei davon sind für externe Geräte frei (Abschnitt 3.3.4). Du kannst also an einem Bus ein flottes TFT-Display mit 40 MHz betreiben und am anderen eine SD-Karte im Vollduplex-Modus, ohne dass sich CS-Leitungen und Taktmodi in die Quere kommen.

Auch I²S (Inter-IC Sound) hat der ESP8266, allerdings nur in einfacher Form. Versuch mal, damit gleichzeitig Audio von einem INMP441-Mikrofon einzulesen und über einen DAC wieder auszugeben. Der ESP32 hat dafür zwei vollwertige I²S-Controller mit DMA (Abschnitt 5.1.3).

1.2.4. CAN und Ethernet: nur beim ESP32

Bei zwei Schnittstellen herrscht auf dem ESP8266 gähnende Leere. CAN kennt er gar nicht. Wer ein Auto oder eine Industriemaschine auslesen wollte, musste einen externen SPI-Controller wie den MCP2515 anflanschen. Der ESP32 hat einen integrierten TWAI-Controller (Two-Wire Automotive Interface, Espressifs Name für CAN, kompatibel mit CAN 2.0B / ISO 11898-1). Dazu kommt nur noch ein externer 3,3-V-Transceiver an zwei beliebigen GPIOs (Abschnitt 4.2.3).

Die zweite ist Ethernet per Kabel. WLAN ist praktisch, bis in der Werkhalle jemand den Kanal zuschreit. Der ESP32 bringt einen integrierten 10/100-Mbit-Ethernet-MAC mit DMA mit. Mit einem kleinen externen PHY-Chip (der Baustein für die elektrische Anbindung ans Netzwerkkabel, z. B. LAN8720) wird aus dem Funkmodul ein stabiler Netzwerkknoten mit RJ45-Buchse.

1.3. Warum der ESP32

Damit kein falscher Eindruck entsteht: Für ein kleines Thermometer, das alle zehn Minuten die Temperatur der Balkonpflanze per WLAN und MQTT (ein schlankes Nachrichtenprotokoll für IoT-Geräte) meldet und danach tief schläft, ist der ESP8266 nach wie vor ein charmanter, spottbilliger Begleiter.

Braucht ein Projekt aber mehrere kabelgebundene Schnittstellen gleichzeitig, etwa GPS, Modbus-Energiezähler, ein Display, eine SD-Karte oder einen Feldbus, wird der ESP8266 zur Sackgasse. Der klassische ESP32 verteilt so etwas entspannt auf seine Hardware:

ESP32 Master-Knoten:

PeripherieSchnittstelle am ESP32
GPS-ModulUART1 (Hardware-Serial)
Modbus-Frequenzumrichter (VFD)UART2 → RS-485-Transceiver
TFT-DisplaySPI3 (VSPI, High-Speed)
BME280/RTC (Echtzeituhr)I²C (Hardware Bus 0)
KFZ-Bus/BMS (Batteriemanagement)TWAI → CAN-Transceiver (Dominant)
I²S-MikroI²S (DMA-Streaming im Hintergrund)

Die Protokolle laufen im Hintergrund, die beiden CPU-Kerne bleiben frei für deine eigentliche Anwendung.

Kleiner Spoiler für Datenblattleser: Wir bleiben in diesem Artikel beim klassischen ESP32. Die neuere Familie hat die Karten neu gemischt: S2 und S3 bekamen USB-OTG, keiner von S2, S3, C3 und C6 hat einen Ethernet-MAC, S2, C3 und C6 haben nur einen I²S-Controller, und einen DAC hat nur noch der S2. Wer zu einem neueren Modell greift, schaut also besser vorher ins Datenblatt.

2. Grundlagen der Signalübertragung

Bevor wir die Protokolle auf unsere Sensoren loslassen, klären wir, wie Bits überhaupt durch einen Draht wandern. Bei Bastelprojekten verbringt man die meiste Zeit bekanntlich nicht mit eleganter Software, sondern damit, fluchend auf ein schwarzes Display zu starren. Meist hat man dann ein paar physikalische Spielregeln übersehen. Um genau die geht es jetzt: serielle gegen parallele Übertragung, die vier Fragen, die jedes Protokoll beantworten muss, und die elektrischen Eigenheiten des ESP32.

2.1. Serielle vs. parallele Signalübertragung

Wir möchten den Buchstaben A vom ESP32 an ein anderes Gerät schicken. Im ASCII-Code ist das die Zahl 0x41, als Byte binär 01000001. Für den Weg zum Empfänger gibt es zwei Ansätze:

Bei der parallelen Übertragung bekommt jedes Bit eine eigene Leitung: acht Datenleitungen, dazu Masse, Takt und Steuerleitungen. Der Sender legt alle acht Bits gleichzeitig an, der Empfänger liest sie auf einen Schlag. Das wirkt schnell, weil 8 Bits simultan fließen. Dafür baut man sich einen Kupferdschungel, und bei hohen Taktraten und langen Leitungen kommen die Bits auf den einzelnen Adern leicht zeitversetzt an (Signal-Skew). Außerdem wären die Pins des ESP32 schneller verbraucht, als man „Steckbrett“ sagen kann.

Bei der seriellen Übertragung wandern die Bits der Reihe nach durch eine Datenleitung. Das spart Leitungen, vereinfacht das Platinen-Routing und erlaubt kompakte Stecker. Mit differenziellen Signalen wie bei RS-485 oder CAN funktioniert das sogar in lauten Industrieumgebungen. „Seriell“ heißt übrigens nicht „nur ein Draht“: UART nutzt getrennte Sende- und Empfangsleitungen (TX/RX), I²C braucht Daten (SDA) und Takt (SCL), SPI hat vier Leitungen (SCK, MOSI, MISO, CS), und RS-485 und CAN nutzen verdrillte Adernpaare.

2.2. Vier Fragen an jedes Protokoll

Weil alle Bits nacheinander über dieselbe Leitung huschen, müssen sich Sender und Empfänger blind verstehen. Jedes Protokoll beantwortet dafür vier Fragen:

  1. Wann tastet der Empfänger ab? Ein digitales Signal wechselt nicht unendlich steil zwischen 0 und 1. Bei UART tastet der Empfänger deshalb in der zeitlichen Mitte des Bits ab (Abschnitt 3.1.2), bei SPI und I²C gibt ein eigenes Taktsignal die Abtastflanke vor.
  2. Wo beginnt und endet eine Übertragung (Framing)? UART klammert jedes Byte mit Start- und Stoppbit. I²C definiert Start- und Stopp-Bedingungen über einen Pegelwechsel auf SDA, während SCL auf High liegt. Modbus RTU nutzt Sendepausen, und I²S streamt Audiodaten endlos im Takt.
  3. Was ist eine 0, was eine 1? 3,3 V und 0 V? Ein Spannungsunterschied zwischen zwei Leitungen A und B? Oder zieht ein Teilnehmer den Bus nur per Open-Drain gegen Masse (Abschnitt 3.2.1)?
  4. Wer darf gerade reden (Buszugriff)? Bei einer Punkt-zu-Punkt-Verbindung wie UART ist das einfach. Ein Bus mit vielen Teilnehmern braucht Regeln, genau wie eine Funkrunde. Bei Master-Slave-Verfahren (I²C, SPI, Modbus; neuere Normtexte sagen Controller/Target) hält die Peripherie den Mund, bis sie gefragt wird. CAN dagegen lässt alle gleichzeitig loslegen und sortiert das über eine zerstörungsfreie Arbitrierung (Abschnitt 4.2.2).

Die vierte Frage begleitet uns durch den ganzen Artikel.

2.3. Logikpegel und GPIO-Matrix

Jetzt zu den Eigenheiten des ESP32, die über Leben und Rauchzeichen deiner Bauteile entscheiden.

2.3.1. Der 3,3-V-Logikpegel

Der ESP32 arbeitet intern und an seinen GPIO-Pins mit 3,3 V Logikpegel. Eine logische 1 (High) liegt nahe 3,3 V, eine logische 0 (Low) bei 0 V (GND).

Wer aus der 5-V-Welt des Arduino Uno kommt, verdrahtet gern 5-V-Sensoren, RS-232-Pegel oder Industrie-Schnittstellen direkt mit den GPIOs. Die Quittung kommt sofort: Der ESP32 ist an seinen Pins nicht 5-V-tolerant, Pegel über 3,3 V zerstören die Eingangsstufen. Für 5-V-Sensoren sind bidirektionale Pegelwandler (engl. level shifter) Pflicht, für Industrie-Schnittstellen braucht es passende Transceiver.

2.3.2. Die GPIO-Matrix: Pins nach Wahl

Zu den besten Eigenschaften des ESP32 gehört die interne GPIO-Matrix. Sie sitzt als flexibles Schaltnetzwerk zwischen den Peripherieblöcken (UART0–2, SPI2/3, I²C, TWAI, also Espressifs CAN-Controller aus Abschnitt 4.2.3, und weitere) und den Pins des Chips:

Du möchtest UART1 nicht an den Standardpins betreiben, sondern auf GPIO 16 und 17? Oder den CAN-Bus auf GPIO 21 und 22 legen? Das legst du einfach beim Initialisieren im Programm fest. Ganz ohne Haken ist die Freiheit aber nicht: Reine Eingangspins und Strapping-Pins sind nicht für alles zu haben, mehr dazu in Abschnitt 6.2.

3. Lokale Board- und Sensorbusse

Jetzt wird gebastelt. Wir verbinden den ESP32 mit Bauteilen, die wenige Zentimeter bis Dezimeter entfernt auf der Werkbank liegen: über UART, I²C, SPI und 1-Wire. Die ersten drei habe ich selbst schon in Betrieb gehabt, bei 1-Wire bin ich Zuschauer. Jedes dieser Protokolle hat seinen eigenen Charakter und seine ganz eigene Methode, den Entwickler in den Wahnsinn zu treiben.

3.1. UART

UART ist der gemütliche Kneipenplausch unter den Protokollen. Es gibt keine gemeinsame Taktleitung, man einigt sich vorher einfach darauf, wie schnell gesprochen wird.

3.1.1. Funktionsprinzip und Baudrate

UART steht für Universal Asynchronous Receiver-Transmitter. Das entscheidende Wort ist asynchron: Sender und Empfänger teilen sich kein Taktsignal, sondern einigen sich vorab auf die Geschwindigkeit (die Baudrate) und das Rahmenformat (frame). Üblich sind 9600 8N1 oder 115200 8N1:

  • Baudrate: 9600 oder 115200 Symbole (bzw. Bits) pro Sekunde. Weil jedes Intervall genau ein Bit trägt, entspricht die Baudrate numerisch der Bitrate.
  • 8: acht Nutzdatenbits (ein Byte)
  • N: keine Parität (None)
  • 1: ein Stoppbit

Ohne gemeinsamen Takt läuft jedes Gerät mit seinem eigenen Oszillator. Weichen die beiden auch nur minimal voneinander ab (Taktdrift), wandert der Abtastzeitpunkt mit jedem Bit weiter aus dem Taktfenster, bis am Ende Datensalat ankommt.

3.1.2. Der UART-Rahmen

In Ruhe (Idle) liegt die Leitung auf High. Zum Start reißt der Sender sie auf Low. Diese fallende Flanke ist das Startbit, und der Empfänger startet damit seine Timer. Danach folgen die Datenbits, und zwar mit dem Least Significant Bit (LSB) zuerst. Unser 'A' (0x41, binär 01000001) purzelt also in der Reihenfolge 1, 0, 0, 0, 0, 0, 1, 0 über den Draht.

Der Empfänger tastet jedes Bit nahe der zeitlichen Mitte ab, weil die Flanken kapazitätsbedingt erst einschwingen müssen. Wer zu nah am Übergang abtastet, liest bei der kleinsten Störung falsch. Optional folgt ein Paritätsbit zur einfachen Fehlerprüfung, dann markiert das Stoppbit (wieder High) das Ende des Bytes und gibt die Leitung für das nächste Zeichen frei.

3.1.3. UART am ESP32

Wie schon in Abschnitt 1.2.1 erwähnt, hat der klassische ESP32 drei vollwertige Hardware-UARTs (UART0, UART1, UART2), alle mit RX und TX. Über die GPIO-Matrix legst du sie auf fast beliebige Pins:

// UART1 auf benutzerdefinierten Pins initialisieren (Baudrate 9600, 8N1, RX=GPIO17, TX=GPIO16)
HardwareSerial MySerial(1);
MySerial.begin(9600, SERIAL_8N1, 17, 16); // Reihenfolge: RX-Pin, TX-Pin

Bei der Verdrahtung gilt eine goldene Regel: TX des ESP32 an RX des Partners, RX an TX, dazu eine gemeinsame Masse (GND). Wer TX an TX lötet, baut eine Leitung, auf der beide gleichzeitig rufen und keiner zuhört. Typische Partner sind GPS-Module, die stur NMEA-Strings (das Textformat für GPS-Daten) heraushauen, GSM/LTE-Modems, serielle Debug-Konsolen oder Nextion-Displays. Bei 5-V-Modulen gilt die Pegelwarnung aus Abschnitt 2.3.1 auch für die RX-Leitung.

3.2. I²C

I²C (Inter-Integrated Circuit) ist das Protokoll für Minimalisten: Ein ganzer Zoo aus Sensoren und Displays teilt sich genau zwei Leitungen.

3.2.1. Open-Drain und Pull-up-Widerstände

Die beiden Leitungen heißen SDA (Serial Data Line) für die Daten in beide Richtungen und SCL (Serial Clock Line) für den Takt, den der Master (der ESP32) erzeugt.

Das elektrische Geheimnis heißt Open-Drain: Kein Teilnehmer legt jemals aktiv High an den Bus. Die Treiber können die Leitungen nur gegen Masse (GND) auf Low ziehen. Zurück auf High holen sie externe Pull-up-Widerstände, die auf 3,3 V hochziehen, sobald alle loslassen. Das ist zugleich die häufigste Fehlerquelle: Ohne Pull-ups hängt der Bus undefiniert im elektrischen Niemandsland.

3.2.2. Das Busprotokoll Schritt für Schritt

Bei I²C herrscht strenge Hierarchie, geredet wird nur, wenn der Master fragt. Ein kompletter Lesezyklus läuft immer gleich ab, zum Beispiel beim Auslesen der Chip-ID (Register 0xD0) eines Umweltsensors BME280, der dort die Kennung 0x60 liefern sollte:

  1. Start-Bedingung: Während SCL auf High liegt, zieht der Master SDA auf Low. Für alle Teilnehmer heißt das: „Ruhe im Bus, es geht los.“
  2. Adressierung: Der Master sendet die 7-Bit-Geräteadresse (beim BME280 0x76 oder 0x77) plus ein Bit für Schreiben oder Lesen.
  3. ACK oder NACK (Acknowledge): Beim 9. Taktimpuls lässt der Master SDA los. Erkennt der Sensor seine Adresse, zieht er SDA auf Low (ACK). Antwortet niemand, bleibt SDA High (NACK). Dann schläft der Sensor, ist falsch verdrahtet oder hat eine andere Adresse.
  4. Registerzeiger: Der Master sendet die Adresse des Zielregisters (0xD0), der Sensor bestätigt wieder mit ACK.
  5. Repeated Start und Datenabruf: Der Master erzeugt eine erneute Start-Bedingung (Repeated Start), schickt die Geräteadresse jetzt mit Lesebit (Read) und taktet das Datenbyte 0x60 aus dem Sensor heraus.
  6. Stopp-Bedingung: Der Master quittiert mit NACK („Ich habe genug gelesen“), danach wechselt SDA von Low auf High, während SCL auf High liegt.

3.2.3. I²C am ESP32

Je länger die Drähte und je mehr Sensoren am Bus hängen, desto größer wird die parasitäre Buskapazität. Die Pull-ups schaffen es dann nicht mehr, die Flanken vor dem nächsten Takt steil auf 3,3 V zu ziehen, und aus sauberen Rechtecken werden Haifischflossen.

Der ESP32 besitzt zwei unabhängige Hardware-I²C-Controller (I²C 0 im Arduino-Core standardmäßig auf GPIO 21/22). Wie man damit zwei Geräte mit gleicher Adresse betreibt, steht in Abschnitt 1.2.2.

3.3. SPI

Wenn I²C der gemächliche Linienbus ist, dann ist SPI (Serial Peripheral Interface) der Rennwagen: keine Adressen, kein Bestätigungsbit, nur Tempo für Displays und SD-Karten.

3.3.1. 4-Draht-Architektur und Vollduplex

SPI setzt auf getrennte Leitungen für Hin- und Rückweg:

  • SCK (Serial Clock): Takt, vom Master erzeugt
  • MOSI (Master Out Slave In): Daten vom ESP32 zum Peripheriegerät
  • MISO (Master In Slave Out): Daten vom Peripheriegerät zum ESP32
  • CS / SS (Chip Select / Slave Select): wählt das Zielgerät aus (meist aktiv Low)

SPI arbeitet vollduplex: Mit jedem Takt wandert ein Bit über MOSI hinaus und gleichzeitig eines über MISO herein, wie zwei Leute, die sich im selben Moment gegenseitig einen Zettel durch die Durchreiche schieben.

3.3.2. Die Sache mit den Dummy-Bytes

Weil der Slave keinen eigenen Takt erzeugt, darf er nicht einfach von sich aus auf MISO senden. Will der ESP32 Daten aus einem SPI-Sensor lesen, schickt er deshalb Dummy-Bytes (z. B. 0xFF oder 0x00) über MOSI hinaus. Die haben keinen Inhalt, sie liefern nur die Taktimpulse auf SCK, mit denen der Sensor seine Antwort über MISO zurückschieben kann.

3.3.3. Taktpolarität (CPOL) und Taktphase (CPHA)

SPI ist nicht gleich SPI. Es gibt vier Modi, festgelegt durch CPOL (Clock Polarity: Liegt SCK in Ruhe auf Low 0 oder auf High 1?) und CPHA (Clock Phase: Werden die Daten an der ersten Flanke 0 oder an der zweiten Flanke 1 abgetastet?). Passen die Modi von Master und Sensor nicht zusammen, liest der ESP32 jedes Bit um einen halben Takt versetzt, und trotz scheinbar perfekter Verdrahtung kommt kompletter Datensalat heraus.

3.3.4. SPI am ESP32

Der klassische ESP32 hat vier SPI-Controller (SPI0–3). SPI0 und SPI1 sind intern für den Flash-Speicher reserviert, für externe Hardware bleiben SPI2 (HSPI) und SPI3 (VSPI). Dort lassen sich Displays, SD-Karten-Module und Ethernet-Controller wie der W5500 parallel und mit hohem Takt anbinden: bis 80 MHz an den festen IO_MUX-Pins, über die GPIO-Matrix höchstens 40 MHz, bei Vollduplex etwa 26 MHz.

3.4. 1-Wire

1-Wire treibt das Sparen auf die Spitze: Versorgung, Masse und eine einzige Datenleitung reichen. Bekanntester Vertreter ist der Temperatursensor DS18B20.

3.4.1. Zeitfenster statt Takt

Wie I²C ist 1-Wire ein Open-Drain-Bus mit externem Pull-up-Widerstand (typisch 4,7 kΩ), nur eben ohne Taktleitung. Jede Aktion beginnt mit Reset und Presence: Der Master zieht die Leitung für ca. 480 µs auf Low und lässt wieder los. Hängt ein Sensor am Bus, meldet er sich kurz darauf mit einem Presence-Puls, indem er die Leitung selbst kurz auf Low zieht. Danach entscheidet allein die Dauer des Low-Pulses über den Bitwert: Ein kurzer Puls (~1–15 µs) ist eine 1, ein langer Puls (~60 µs) eine 0.

3.4.2. Die 64-Bit-ROM-ID

Jeder 1-Wire-Chip trägt eine weltweit einmalige, fest eingebrannte 64-Bit-ROM-Adresse. Deshalb kannst du Dutzende Temperatursensoren an denselben GPIO klemmen. Der ESP32 scannt den Bus, listet alle Adressen auf und fragt danach jeden Sensor gezielt nach seiner Temperatur.

3.4.3. Wandlungszeit und 85-°C-Phänomen

Wer zum ersten Mal einen DS18B20 programmiert, stolpert über zwei Dinge. Das erste ist die Wandlungszeit. Der Sensor ist kein simpler Spannungsteiler, sondern ein winziger Computer: Nach dem Befehl „Temperatur messen!“ braucht er bei voller 12-Bit-Auflösung bis zu 750 Millisekunden. Wer sofort liest, bekommt veraltete oder ungültige Werte.

Das zweite ist das 85-°C-Phänomen. Zeigt der Sensor plötzlich genau 85 °C an, ist das Zimmer nicht schlagartig zur Sauna geworden. 85 °C ist der Power-On-Reset-Wert des Temperaturregisters. Taucht er auf, gab es während der Wandlung einen Spannungseinbruch, die Verkabelung wackelt, oder die Leseanforderung kam zu früh nach einem Reset.

4. Industrielle Feldbusse

Bisher saßen wir in der Komfortzone des Schreibtischs. Ein Sensor hier, ein Jumperkabel dort, das verzeiht fast jede elektronische Sünde. Steckt der ESP32 aber im Schaltschrank neben einem Elektromotor, oder sollen Daten über dreißig Meter Kabeltrasse durch eine Werkhalle, sieht die Welt anders aus. Schaltet nebenan ein Frequenzumrichter oder ein Schütz, macht das Störfeld aus jedem UART- oder I²C-Paket Datensalat.

Hier schlägt die Stunde von zwei Veteranen: RS-485 mit Modbus RTU und dem CAN-Bus, den der ESP32 unter dem Namen TWAI kennt. Beide beantworten die Frage, wer gerade reden darf, auf völlig unterschiedliche Weise.

4.1. RS-485 und Modbus RTU

Ein verbreiteter Irrglaube lautet: „Ich programmiere mal eben ein bisschen RS-485.“ Tatsächlich arbeiten hier zwei Spezialisten im Team. RS-485 kümmert sich um die Physik, also darum, wie die Bits elektrisch durchs Kabel kommen. Modbus RTU ist das Protokoll und legt fest, was die Bytes bedeuten.

Das Schichten-Duo:

SchichtZuständigAufgabe
Anwendungs-EbeneModbus RTUBefehle, Register, Prüfsumme
Physikalische SchichtRS-485Differenzielle Spannungen A vs. B; Transceiver wandelt UART-Pegel um

4.1.1. Differenzielle Signale

Warum überlebt RS-485 dort, wo normales UART nach wenigen Metern stirbt? UART misst die Spannung einer Signalleitung gegen die gemeinsame Masse (single-ended). Fährt eine Störspitze ins Kabel, hebt sie die Spannung an, und der Empfänger sieht eine Eins statt einer Null.

RS-485 nutzt stattdessen zwei verdrillte Adern, meist A und B genannt. Der Sender legt das Signal invertiert auf beide: Ist A positiver als B, gilt das als der eine Zustand, ist B positiver als A, als der andere. Der Empfänger misst ausschließlich die Spannungsdifferenz ($V_A-V_B$).

Eine Störung von außen trifft beide Adern gleich stark. Weil der Empfänger nur die Differenz bildet, zieht sie sich selbst ab:

$$(V_A+V_{\text{Stör}})-(V_B+V_{\text{Stör}})=V_A-V_B$$

Einfach und unverschämt robust.

4.1.2. Halbduplex und Richtungsumschaltung

Meist teilen sich Hin- und Rückweg dieses eine Adernpaar (Halbduplex). Das ist wie in einer Funkrunde auf einer Frequenz: Immer nur einer sendet, alle anderen hören zu.

Damit der ESP32 mitspielen kann, braucht er einen externen RS-485-Transceiver (z. B. MAX3485 für 3,3 V; der verbreitete MAX485 braucht 5 V). Der hat neben RX und TX zwei Steuerpins: DE (Driver Enable) schaltet den Sender ein, RE (Receiver Enable, aktiv Low) den Empfänger.

Die klassische Bastlerfalle: Man verbindet DE und RE, zieht beide auf High und schickt die Anfrage los. Vergisst man danach, den Pin schnell wieder auf Low zu ziehen, bleibt der Transceiver auf Senden. Der Slave antwortet brav, aber der ESP32 hört nichts, weil sein eigener Empfänger noch taub geschaltet ist. Das ist der Funker, der die Sendetaste nicht loslässt und sich wundert, warum keiner antwortet. Der UART-Treiber des ESP32 kennt dafür einen RS-485-Halbduplexmodus, in dem er die RTS-Leitung automatisch umschaltet (im Interrupt, also mit kleiner Verzögerung).

4.1.3. Terminierung und Fail-Safe-Biasing

Bei schnellen Flanken verhält sich ein RS-485-Kabel wie eine Badewanne: Trifft die Welle auf das offene Ende, schwappt sie als Reflexion zurück und zerstört die folgenden Bits. Deshalb gehört an die beiden physikalisch äußersten Enden des Busses je ein Abschlusswiderstand von 120 Ω zwischen A und B (Terminierung).

Sendet gerade niemand, schweben A und B elektrisch in der Luft. Fail-Safe-Widerstände (biasing) zwingen den Bus dann in einen definierten Ruhezustand, damit der Empfänger nicht anfängt, Rauschen als Startbits zu deuten.

4.1.4. Modbus RTU: die Verkehrsordnung

Wenn RS-485 die Straße ist, dann ist Modbus RTU die Straßenverkehrsordnung. Es ist ein striktes Master-Slave-Verfahren: Der ESP32 (Master) fragt, das angesprochene Gerät (Slave) antwortet, und niemand spricht unaufgefordert.

Schauen wir uns ein echtes Telegramm an. Der ESP32 will von einem Energiezähler mit der Slave-Adresse 1 zwei Messwerte (Holding Registers, 16-Bit-Speicherplätze im Gerät) ab Registeradresse 0 abrufen:

Master-Anfrage: 01 03 00 00 00 02 C4 0B

BytesBedeutung
01Slave-Adresse (Gerät 1)
03Funktionscode (03 = Read Holding)
00 00Start-Register (0x0000)
00 02Anzahl Register (2 Stück)
C4 0BCRC-16-Prüfsumme

Drei Eigenheiten solltest du kennen. Modbus RTU hat keine Start- oder Stoppzeichen. Ein Telegramm beginnt und endet durch Stille auf dem Bus, also eine Pause von mindestens 3,5 Zeichenlängen. Trödelt dein Code mitten im Senden wegen eines Delays herum, halten die Slaves die Pause für das Telegrammende und werfen den Rest als Datenmüll weg.

Am Ende jedes Telegramms kleben außerdem zwei Prüfbytes, die CRC-16-Prüfsumme (Low-Byte zuerst). Kippt unterwegs auch nur ein Bit, passt sie nicht mehr, und das Telegramm wird kommentarlos ignoriert.

Und dann ist da noch das Datenblatt-Rätsel. Modbus sagt dir zwar, dass in Register 0x0001 eine Zahl steht. Ob das die Netzspannung in Volt, die Frequenz in 0,1 Hertz oder die Motortemperatur in Kelvin ist, verrät nur das oft kryptische PDF-Handbuch des Herstellers.

4.2. CAN-Bus und TWAI

Wenn Modbus eine Behörde ist, in der nur der Chef Fragen stellen darf, dann ist der CAN-Bus (Controller Area Network) ein Parlament, in dem jeder jederzeit aufstehen und losreden darf. Trotzdem redet nie jemand durcheinander. Bosch hat CAN ursprünglich für Autos entwickelt, um kilometerlange Kabelbäume einzudampfen. Heute ist es das Rückgrat von Fahrzeugen, Drohnen, Robotern und Industrieanlagen.

4.2.1. Multi-Master-Prinzip und Broadcasting

Bei CAN gibt es weder Master noch Slaves noch Geräteadressen. Alle Knoten hängen gleichberechtigt am Bus, und jede Nachricht geht als Broadcast an alle. Sie trägt einen Identifier (ID), z. B. 0x123. Der sagt nicht, wer die Nachricht bekommen soll, sondern was drinsteht, etwa „Motordrehzahl“ oder „Batteriespannung“. Jeder Knoten filtert selbst heraus, was ihn interessiert.

4.2.2. Arbitrierung: Vorfahrt ohne Kollision

Was passiert, wenn zwei Knoten im selben Mikrosekundenbruchteil loslegen? Wir Funkamateure kennen das als Pile-up: Alle rufen gleichzeitig, und mit etwas Pech versteht man keinen. Beim klassischen Ethernet mit gemeinsamem Kabel (CSMA/CD) gäbe es eine Kollision, und beide müssten warten. CAN löst das mit dominanten und rezessiven Bits. Ein dominantes Bit (logisch 0) überschreibt alles auf dem Bus, ein rezessives Bit (logisch 1) weicht zurück, sobald jemand eine dominante 0 anlegt.

Arbitrierung auf dem Bus (Knoten 1 verliert gegen Knoten 2):

Bit-Position1234 (Entscheidung!)Ergebnis
Knoten 1 (ID 0x0A0)0001 (rezessiv)Verliert! Schaltet sofort stumm!
Knoten 2 (ID 0x020)0000 (dominant)Gewinnt den Bus!
Tatsächlicher Bus0000Signal bleibt völlig unbeschädigt!

Jeder Knoten hört beim Senden seiner ID bitweise mit, was tatsächlich auf dem Bus liegt. Die ersten drei Nullen senden beide synchron, der Bus bleibt auf 0. Bei Bit 4 möchte Knoten 1 eine 1 (rezessiv) senden, liest aber eine 0 zurück. Er weiß sofort: „Hoppla, da drüben sendet jemand mit höherer Priorität.“ Noch im selben Takt bricht er ab und wechselt in den Empfangsmodus. Knoten 2 merkt davon nichts, seine Nachricht läuft ohne jede Signalbeschädigung weiter.

Daraus folgt die eiserne Regel: Je kleiner die ID, desto höher die Priorität (ID 0x001 schlägt alles). Ein Pile-up, in dem der Wichtigste sofort durchkommt und die anderen höflich verstummen, davon träumt jeder Contest-Funker.

4.2.3. TWAI am ESP32

Espressif nennt seinen integrierten CAN-Controller TWAI (Two-Wire Automotive Interface). Rund um TWAI gibt es zwei beliebte Irrtümer.

Der erste betrifft den Transceiver. Der ESP32 hat zwar die komplette CAN-Logik an Bord, an seinen GPIOs liegen aber nur gewöhnliche 3,3-V-Logikpegel. Direkt ans CAN-Kabel darf er deshalb nicht. Dazwischen gehört ein externer 3,3-V-CAN-Transceiver wie der SN65HVD230, der die Signale auf die differenziellen Leitungen CAN_H und CAN_L umsetzt.

Der zweite betrifft den Standard. Der klassische ESP32 kann CAN 2.0A (11-Bit-Identifier) und CAN 2.0B (29-Bit-Identifier) mit maximal 8 Bytes Nutzlast pro Datenrahmen. Das moderne CAN FD (Flexible Data-Rate, bis zu 64 Bytes Nutzdaten) beherrscht er nicht. Hängst du ihn an ein Fahrzeugnetz mit CAN FD, scheitert die Kommunikation kläglich. Der neuere ESP32-C5 beherrscht CAN FD (Stand: November 2026).

Achtung Pin-Konflikt: GPIO 21/22 sind im Arduino-Core auch die I²C-Standardpins. Wer beides braucht, legt TWAI über die GPIO-Matrix auf andere freie Pins.

4.2.4. TWAI initialisieren

Mit dem integrierten Treiber ist TWAI schnell aufgesetzt. Die Konfiguration besteht aus drei Blöcken: Pins und Betriebsmodus, Bitrate, Filter.

#include <driver/twai.h>

void setup() {
    // 1. Pins und Betriebsmodus festlegen (z. B. TX=GPIO21, RX=GPIO22)
    twai_general_config_t g_config = TWAI_GENERAL_CONFIG_DEFAULT(GPIO_NUM_21, GPIO_NUM_22, TWAI_MODE_NORMAL);

    // 2. Bus-Geschwindigkeit definieren (Standard im KFZ/Industrie: 500 kbit/s oder 250 kbit/s)
    twai_timing_config_t t_config = TWAI_TIMING_CONFIG_500KBITS();

    // 3. Hardware-Filter: Alle Nachrichten durchlassen oder nur bestimmte IDs abholen
    twai_filter_config_t f_config = TWAI_FILTER_CONFIG_ACCEPT_ALL();

    // Treiber installieren und starten
    if (twai_driver_install(&g_config, &t_config, &f_config) == ESP_OK) {
        twai_start(); // Bus ist scharf geschaltet!
    }
}

Stand: November 2026: ESP-IDF empfiehlt seit Version 5.5 den neuen Treiber esp_twai.h. Der hier verwendete ältere driver/twai.h gilt als Altlast (legacy) und bekommt keine neuen Funktionen mehr, läuft aber noch.

5. Audio- und Analogschnittstellen

Nach dem Feldbus-Dschungel aus Differenzspannungen und Prüfsummen wechseln wir die Welt. Hier geht es nicht mehr darum, alle paar Sekunden ein träges Temperatur-Byte aus einem Sensor zu kitzeln. Jetzt fließen die Daten ununterbrochen: als digitaler Audiostrom über I²S oder als analoges Signal, für das wir die digitale Natur des ESP32 mit PWM, ADC und DAC austricksen.

5.1. I²S

Wer zum ersten Mal versucht, Audiodaten über UART oder I²C zu schaufeln, erlebt sein blaues Wunder: Knacken, Ruckeln, Aussetzer und eine CPU, die bei 100 % Auslastung kapituliert. Audiodaten verzeihen keine Pausen. Reißt der Strom auch nur für ein paar Mikrosekunden ab, protestiert das Ohr sofort. Dafür wurde I²S (Inter-IC Sound) geschaffen.

5.1.1. Datenstrom ohne Protokoll

Anders als UART kennt I²S keine Start- und Stoppbits, anders als I²C keine Geräteadressen und keine Bestätigungsbits (ACK/NACK). Die Daten laufen als endloser Strom im Takt, links und rechts wechseln sich brav ab, mehr Gesprächsregeln braucht es nicht. Eine typische I²S-Verbindung hat drei Leitungen:

  • BCLK (Bit Clock, auch SCK): der Herzschlag. Jeder Taktimpuls schiebt genau ein Bit aus dem Mikrofon herein oder in den Lautsprecher-Verstärker hinaus.
  • WS (Word Select, auch LRCLK für Left-Right Clock): sagt, in welche Ohrmuschel der Ton gehört. Typischerweise steht Low für den linken Kanal und High für den rechten.
  • SD (Serial Data): die eigentlichen Audio-Samples, typischerweise MSB first.

Typische Partner sind digitale MEMS-Mikrofone wie das beliebte INMP441, digitale Audioverstärker wie der MAX98357A oder DAC-Platinen wie der PCM5102.

5.1.2. Die Taktrechnung

Bei I²S müssen die Frequenzen auf den Punkt stimmen. Ist der Takt falsch berechnet, klingt die eigene Stimme wie Micky Maus auf Helium oder wie ein verlangsamter Dämon. Kaffee bereitstellen, es wird kurz mathematisch. Die Grundformel für die Bit-Clock-Frequenz lautet:

$$\text{BCLK-Frequenz} = \text{Sampling-Rate} \times \text{Kanalanzahl} \times \text{Slot-Breite}$$

Rechnen wir ein typisches Studio-Szenario durch:

  • Sampling-Rate: 48.000 Abtastwerte pro Sekunde (48 kHz)
  • Kanäle: 2 (Stereo: links und rechts)
  • Slot-Breite: 32 Bit pro Sample-Slot

$$\text{BCLK} = 48\,000 \times 2 \times 32 = 3\,072\,000 \text{ Hz} = 3{,}072 \text{ MHz}$$

Gemein wird es bei der Slot-Breite. Ein Sample trägt oft nur 24 Bit echte Audioauflösung, reist aber in einem 32-Bit-Container. Sind sich Sender und Empfänger bei Slot-Breite, Kanalzuordnung oder Datenausrichtung uneinig, hörst du entweder lautes digitales Kreischen oder gar nichts.

5.1.3. DMA entlastet die CPU

Bei über 3 Millionen Bits pro Sekunde wäre jede CPU sofort totgearbeitet, müsste sie jedes Bit einzeln per Software-Interrupt abholen. Der ESP32 koppelt seine zwei I²S-Controller deshalb direkt an DMA-Puffer (Direct Memory Access). Der I²S-Block schaufelt die ankommenden Audioblöcke selbstständig in den RAM, und die CPU wird erst per Interrupt angetippt, wenn ein ganzer Pufferblock (z. B. 64 oder 512 Samples) voll ist. Deshalb kann der ESP32 nebenbei MP3s dekodieren oder Webradio streamen, während der Audiostrom im Hintergrund weiterläuft.

5.2. PWM, ADC und DAC

Ein Mikrocontroller denkt stur binär: 0 (GND) oder 1 (3,3 V). Die Welt da draußen ist aber analog. Eine Lampe wird stufenlos heller, ein Motor beschleunigt sanft, ein Drucksensor liefert eine kontinuierliche Spannung. Für diese Welt hat der ESP32 drei Werkzeuge.

5.2.1. PWM: die digitale Sinnestäuschung

PWM steht für Pulsweitenmodulation. Wie bringt man eine LED dazu, mit halber Helligkeit zu leuchten, wenn der Pin nur ganz an oder ganz aus kennt? Man schaltet ihn so schnell an und aus, dass das Auge (oder die Trägheit eines Elektromotors) nur noch den zeitlichen Mittelwert wahrnimmt. Das ist im Grunde Disco mit dem Lichtschalter, nur sehr viel schneller.

Entscheidend sind zwei Größen: die Frequenz (f), also wie oft pro Sekunde das Signal umschaltet (in Hertz), und der Tastgrad (duty cycle), der Anteil der Zeit, in der das Signal innerhalb eines Zyklus auf High steht. Bei 0 % ist der Pin dauerhaft aus, bei 100 % dauerhaft an.

Der ESP32 erzeugt PWM nicht hemdsärmelig per CPU-Delay, sondern mit eigener Hardware. LEDC (LED Control) ist für feinfühliges Dimmen gedacht und bietet bis zu 16 Hardware-Kanäle mit frei einstellbarer Frequenz und Auflösung (bis 20 Bit; je höher die Frequenz, desto geringer die mögliche Auflösung). MCPWM (Motor Control PWM) ist ein eigener Block für DC-Motoren, Schrittmotoren und Wechselrichter, inklusive Totzeiterzeugung (dead time).

5.2.2. ADC: Spannung messen

Soll der ESP32 die Restspannung einer Batterie messen oder ein Drehpoti auslesen, wandelt der ADC (Analog-to-Digital Converter) die kontinuierliche Spannung in eine Ganzzahl um.

Typisch sind 12 Bit Auflösung: Der Messbereich wird in 2¹² = 4096 Stufen geteilt (Werte von 0 bis 4095). Die Umrechnung lautet:

$$\text{Spannung} \approx \text{ADC-Wert} \times \left(\frac{3{,}3\text{ V}}{4095}\right)$$

Das ist eine Näherung: Bei maximaler Dämpfung empfiehlt Espressif für den klassischen ESP32 einen Messbereich von 150 bis 2450 mV, darüber und darunter wird es ungenau.

Damit sind wir bei der bitteren Praxiswahrheit. Der interne ADC des klassischen ESP32 ist berüchtigt für seine Nichtlinearität. An den Rändern (nahe 0 V und nahe 3,3 V) wird die Messkurve ungenau, und rauschanfällig ist er obendrein. Wer Laborpräzision braucht, greift zu externen I²C-Wandlern wie dem ADS1115. Außerdem hängt ADC2 intern mit dem WLAN-Modul zusammen: Ist WLAN aktiv, ist ADC2 nicht nutzbar, weil das WLAN Vorrang hat. Analoge Sensoren gehören deshalb an ADC1 (GPIOs 32–39).

5.2.3. DAC: echte Analogspannung

PWM gaukelt eine analoge Spannung nur vor und bleibt ohne Tiefpassfilter ein Rechtecksignal. Der klassische ESP32 hat zusätzlich zwei echte integrierte 8-Bit-DAC-Kanäle (Digital-to-Analog Converter), fest verdrahtet an GPIO 25 (DAC1) und GPIO 26 (DAC2). Mit dacWrite(25, wert) (Werte von 0 bis 255) liefert der Pin eine echte Gleichspannung zwischen 0 V und 3,3 V:

$$\text{Ausgangsspannung} = \text{Wert} \times \left(\frac{3{,}3\text{ V}}{255}\right)$$

Damit lassen sich Sinuswellen für Testsignale erzeugen oder alte analoge Audioverstärker direkt ansteuern, ohne dass du eine PWM-Filterschaltung berechnen musst.

6. Planung in der Praxis

Du sitzt vor einem leeren Steckbrett, der Kopf ist voller Ideen, und auf dem Tisch türmen sich Sensoren, Displays, Pegelwandler und Motortreiber. Die Euphorie verfliegt in dem Moment, in dem dir klar wird: „Mein ESP32 hat nur eine begrenzte Zahl an Pins, und wenn ich den falschen erwische, bootet er nicht mal mehr.“ Mit meinem geplanten Antennenrotor stehe ich genau an diesem Punkt. Bringen wir also Ordnung ins Chaos: welches Protokoll wofür taugt, wie man die Pins verteilt und wie Software und Hardware zusammenspielen, damit die CPU nicht Däumchen dreht, während der Bus im Stau steht.

6.1. Welches Protokoll wofür?

Das eine perfekte Protokoll gibt es nicht, nur das, das für deinen Fall die wenigsten Schmerzen verursacht. Wer ein TFT-Farbdisplay über I²C ansteuert, baut eine Ruckelorgie; wer ein simples Thermometer per SPI anbindet, verschwendet Leitungen. Hier die drahtgebundenen Protokolle im direkten Vergleich:

ProtokollLeitungen (ohne Versorg.)Durchsatz / Distanz (Praxis)Topologie & TeilnehmerTypische Peripherie & Einsatzzweck
UART2 (TX, RX) + GND9600 Baud bis mehrere Mbit/s
Wenige Meter
Punkt-zu-Punkt (1:1)GPS-Module, Debug-Konsolen, Funktransceiver
I²C2 (SDA, SCL)100 kbit/s bis 400 kbit/s (Fast)
< 1–2 Meter (kapazitätskritisch)
Multi-Drop (bis 112 Geräte, 7-Bit-Adresse)OLED-Displays, RTCs, Umweltsensoren (BME280)
SPI3 + 1 je Slave (SCK, MOSI, MISO, CS)Hoch (10 bis 40+ MHz)
Sehr kurz (meist Board-Ebene)
Master-Slave (Shared Bus + dedizierte CS)Farb-TFT-Displays, SD-Karten-Module, Flash
1-Wire1 (Data) + GNDSehr langsam (~16 kbit/s)
Mehrere Meter (mit sauberem Pull-up)
Multi-Drop (eindeutige 64-Bit-ROM-ID)DS18B20 Temperatursensoren
RS-485 / Modbus2 (differenziell A & B)9600 bis 115200 Baud (bis Mbit)
Bis ca. 1200 Meter (bei 100 kbit/s)
Halbduplex-Bus (1 Master, viele Slaves)VFD-Frequenzumrichter, Energiezähler, SPS (speicherprogrammierbare Steuerung)
CAN / TWAI2 (differenziell H & L)125 kbit/s bis 1 Mbit/s
Dutzende bis Hunderte Meter
Multi-Master (Arbitrierung per Identifier)Motorsteuerungen, Batterie-Management (BMS), KFZ
I²S3 (BCLK, WS, SD)Mehrere MHz (Audio-Takt)
Sehr kurz (Chip-zu-Chip)
Streaming (Punkt-zu-Punkt / Multi-Channel)Digitale Mikrofone (INMP441), Audio-DACs / Codecs

6.1.1. Entscheidungsbaum

Wer es lieber als Entscheidungsweg mag, geht diesen Baum von oben nach unten durch:

6.2. Pins richtig belegen

Die GPIO-Matrix (Abschnitt 2.3.2) legt fast jedes interne Signal auf fast jeden Pin. Klingt nach grenzenloser Freiheit, bis man die falschen Pins erwischt und die Platine sich benimmt wie eine launische Diva. Ein paar GPIOs haben nämlich einen ganz eigenen Charakter, den du kennen solltest, bevor der Lötkolben heiß wird:

ESP32 DevKit (30/36 Pin):

GPIOEinstufungGrundWas passiert
34, 35, 36 (VP), 39 (VN)Nur Eingänge!Kein Output, kein Pull-upReine Eingangspins (input-only) ohne Ausgangstreiber und ohne interne Pull-up- oder Pull-down-Widerstände. Gut als analoge Messeingänge (ADC) oder RX-Eingänge für UART, aber niemals als TX-, SCL- oder Taktleitungen.
6, 7, 8, 9, 10, 11Finger weg!Interner SPI-Flash-SpeicherAuf vielen Entwicklungsboards an der Stiftleiste, aber direkt am internen SPI-Flash. Schließt man an GPIO 6 eine LED oder eine I²C-Leitung an, stürzt der Chip ab (Guru Meditation Error) oder startet ständig neu, weil er seinen Programmcode nicht mehr aus dem Flash lesen kann.
0, 2, 5, 12, 15Strapping-Pins!Bestimmen den Boot-ModusWerden im Einschaltmoment (Boot-Vorgang) gelesen. Zieht ein Sensor GPIO 0 auf Masse, bleibt der ESP32 stumm im Bootloader hängen. Zieht ein Relais oder Transceiver GPIO 12 auf High, schaltet der Spannungsregler des Flash-Speichers auf 1,8 V statt 3,3 V: Bootschleife. Für Busleitungen mit externen Pull-up-Widerständen meiden.
21, 22, 16, 17, 18, 19 …Grünes Licht!Freie Fahrt für UART/I²CAusnahme: Auf Modulen mit PSRAM (z. B. WROVER) sind GPIO 16/17 belegt.

Für analoge Messungen gilt außerdem: ADC1 (GPIOs 32–39) nutzen, denn ADC2 ist bei aktivem WLAN nicht nutzbar (Abschnitt 5.2.2).

6.3. Software: FreeRTOS, Interrupts, DMA

Einen ESP32 zu programmieren wie einen alten 8-Bit-Arduino, mit einem riesigen loop() voller delay(1000), ist, als würde man einen Sportwagen im ersten Gang durch die Fußgängerzone schieben. Der klassische ESP32 hat zwei 32-Bit-Prozessorkerne (Core 0 und Core 1) und läuft standardmäßig unter dem Echtzeit-Betriebssystem FreeRTOS. Wer mehrere Busse parallel betreibt, organisiert die Software deshalb in drei Stufen:

Die erste Stufe überlässt DMA (Direct Memory Access) die Drecksarbeit. Bei datenhungrigen Schnittstellen wie I²S (Audio) oder SPI (Displays, SD-Karten) erledigt DMA die Transfers ohne die CPU (Abschnitt 5.1.3).

Die zweite Stufe heißt Interrupts statt Polling. Statt in einer Schleife panisch abzufragen, ob ein CAN-Rahmen angekommen ist (Polling), registriert der TWAI-Treiber einen Handler für die Interrupt Service Routine (ISR). Der wartende Task schläft und wird erst geweckt, wenn ein gültiger Rahmen fertig im Puffer liegt.

Die dritte Stufe ist die Aufgabenteilung per FreeRTOS-Tasks und Queues. Ein Kommunikations-Task läuft mit hoher Priorität (z. B. auf Core 0, auf dem standardmäßig auch der WLAN-Stack läuft), liest den CAN-Bus oder RS-485 aus und wirft die Rohdaten in eine thread-sichere FreeRTOS Queue. Ein zweiter Task für Verarbeitung und Display läuft entspannt auf Core 1, holt die Pakete aus der Queue, zeichnet sie auf das SPI-Display oder schickt sie per MQTT ins Heimnetz. Bricht auf dem Feldbus kurz die Hölle los, stottert weder das Display noch der Regelkreis.

Am Ende läuft alles auf die Frage aus der Funkrunde hinaus: Wer darf gerade reden? UART lässt zwei am Kneipentisch plaudern, bei I²C, SPI und Modbus erteilt der Master das Wort, I²S redet einfach im Takt durch, und CAN löst den Pile-up so sauber, dass jeder Contest-Funker neidisch wird. Wer weiß, wie Startbits getaktet werden, warum I²C ohne Pull-ups stirbt, weshalb RS-485 Störungen einfach wegrechnet und wie CAN-Knoten ohne Kollision um die Vorfahrt kämpfen, muss nicht mehr Bibliotheken herunterladen und hoffen. Der ESP32 liefert das Werkzeug frei Haus, man muss nur wissen, an welchem Pin man es abholt. Für meinen Rotor weiß ich jetzt jedenfalls, womit ich anfange: mit dem Pinplan.


Hier klicken, um den Inhalt von Spotify anzuzeigen.
Erfahre mehr in der Datenschutzerklärung von Spotify (öffnet in neuem Tab).

Schreib einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.