UART zwischen Arduino und ESP32: Serielle Verbindung mit Pegelwandlung richtig aufbauen

UART in 5 Minuten: TX, RX, Baudrate

UART (Universal Asynchronous Receiver Transmitter) ist die älteste und einfachste Verbindung zwischen zwei Controllern: eine Leitung pro Richtung, kein Taktsignal, keine Adressen. Jedes Board hat einen TX-Pin (Transmit, senden) und einen RX-Pin (Receive, empfangen). Die goldene Regel: TX des einen an RX des anderen – die Leitungen werden gekreuzt, denn was der eine sendet, soll der andere empfangen. Dazu kommt zwingend eine gemeinsame GND-Verbindung, sonst fehlt den Signalen der Bezugspunkt.

Weil kein Takt mitübertragen wird, müssen sich beide Seiten vorab auf ein Tempo einigen: die Baudrate. Übliche Werte sind 9600 oder 115200 Baud – wichtig ist nur, dass beide Seiten denselben Wert nutzen, sonst kommt Zeichensalat an.

• Punkt-zu-Punkt: UART verbindet genau zwei Teilnehmer – für ganze Board-Netzwerke gibt es CAN-Bus oder ESP-NOW
• Kabelgebunden und störsicher: Bei kurzen Strecken (unter ~1 m) völlig unkritisch
• In jedem Board eingebaut: Keine Zusatzmodule, keine Bibliotheken nötig
• Der Serielle Monitor nutzt dasselbe Prinzip: USB-Debugging ist nichts anderes als UART über einen USB-Wandler

Das brauchst du

1Pegelwandlung: 5 V treffen auf 3,3 V

Hier liegt die wichtigste Stolperfalle des ganzen Projekts: Der UNO sendet auf seinem TX-Pin 5-V-Signale, die RX-Pins des ESP32 sind aber nur für 3,3 V ausgelegt. Direkt verbinden kann den ESP32-Pin auf Dauer beschädigen. Die Lösung ist ein Spannungsteiler aus zwei Widerständen:

UNO TX (5V) ----[ 1 kΩ ]----+----[ 2 kΩ ]---- GND
                            |
                            +----> ESP32 RX (ca. 3,3V)

Die Rechnung dahinter: U = 5 V × 2k / (1k + 2k) = 3,33 V – exakt im grünen Bereich. Die Gegenrichtung braucht keinen Teiler: Die 3,3-V-Signale vom ESP32-TX erkennt der UNO problemlos als HIGH (alles über ~3 V gilt bei 5-V-AVRs als HIGH).

Die komplette Verkabelung

2Erster Kontakt: Ping-Pong zwischen den Boards

Zwei Minimal-Sketches prüfen die Verbindung. Der UNO sendet jede Sekunde einen Zählerwert, der ESP32 quittiert jeden Empfang. Zuerst der UNO:

// Sketch fuer den ARDUINO UNO
#include <SoftwareSerial.h>

SoftwareSerial espSerial(2, 3);   // RX = D2, TX = D3

unsigned long zaehler = 0;

void setup() {
  Serial.begin(115200);      // USB: Serieller Monitor
  espSerial.begin(9600);     // Verbindung zum ESP32
  Serial.println("UNO bereit.");
}

void loop() {
  // jede Sekunde eine Nachricht senden
  static unsigned long letzterVersand = 0;
  if (millis() - letzterVersand >= 1000) {
    letzterVersand = millis();
    zaehler++;
    espSerial.print("PING:");
    espSerial.println(zaehler);      // println haengt \n an - unser Endezeichen
  }

  // Antworten vom ESP32 im Monitor anzeigen
  if (espSerial.available()) {
    String antwort = espSerial.readStringUntil('\n');
    Serial.print("ESP32 antwortet: ");
    Serial.println(antwort);
  }
}

Und das Gegenstück für den ESP32:

// Sketch fuer den ESP32
#define RXD2 16
#define TXD2 17

void setup() {
  Serial.begin(115200);                          // USB-Monitor
  Serial2.begin(9600, SERIAL_8N1, RXD2, TXD2);   // UART zum UNO
  Serial.println("ESP32 bereit.");
}

void loop() {
  if (Serial2.available()) {
    String nachricht = Serial2.readStringUntil('\n');
    nachricht.trim();                            // \r und Leerzeichen entfernen

    Serial.print("Empfangen: ");
    Serial.println(nachricht);

    // Quittung zurueckschicken
    Serial2.print("PONG zu [");
    Serial2.print(nachricht);
    Serial2.println("]");
  }
}

Öffne beide Serielle Monitore (zwei IDE-Fenster oder IDE + zweites Terminal): Auf dem ESP32 laufen die PINGs ein, auf dem UNO die PONGs – die Brücke steht!

3Praxisprojekt: Der UNO als Sensor-Satellit

Jetzt wird es nützlich: Der UNO liest zwei Analogwerte (z. B. einen Bodenfeuchte-Sensor an A0 und einen ALS-PT19 Lichtsensor an A1) und schickt sie als kompakte CSV-Zeile im Format DATEN:feuchte,licht an den ESP32. Der parst die Zeile robust und hätte die Werte damit bereit fürs WLAN:

// Sketch fuer den ARDUINO UNO: misst und sendet
#include <SoftwareSerial.h>

SoftwareSerial espSerial(2, 3);   // RX = D2, TX = D3

void setup() {
  Serial.begin(115200);
  espSerial.begin(9600);
}

void loop() {
  static unsigned long letzteMessung = 0;
  if (millis() - letzteMessung >= 2000) {
    letzteMessung = millis();

    int feuchte = analogRead(A0);   // 0-1023
    int licht   = analogRead(A1);   // 0-1023

    // kompaktes Format: DATEN:512,308
    espSerial.print("DATEN:");
    espSerial.print(feuchte);
    espSerial.print(",");
    espSerial.println(licht);
  }
}

// Sketch fuer den ESP32: empfaengt und parst
#define RXD2 16
#define TXD2 17

void setup() {
  Serial.begin(115200);
  Serial2.begin(9600, SERIAL_8N1, RXD2, TXD2);
}

void loop() {
  if (Serial2.available()) {
    String zeile = Serial2.readStringUntil('\n');
    zeile.trim();

    // nur Zeilen mit unserem Prefix akzeptieren
    if (zeile.startsWith("DATEN:")) {
      String nutzdaten = zeile.substring(6);        // alles nach dem Prefix
      int trennung = nutzdaten.indexOf(',');

      if (trennung > 0) {
        int feuchte = nutzdaten.substring(0, trennung).toInt();
        int licht   = nutzdaten.substring(trennung + 1).toInt();

        Serial.printf("Bodenfeuchte: %d | Licht: %d\n", feuchte, licht);
        // hier weiterverarbeiten: MQTT, Webserver, Telegram ...
      }
    }
  }
}

Das Prefix DATEN: plus Endezeichen \n macht das Protokoll robust: Der ESP32 ignoriert Störzeichen und halbe Zeilen, statt Fantasiewerte zu parsen. Die empfangenen Werte kannst du direkt weiterreichen – etwa per MQTT an Home Assistant, über einen ESP32-Webserver oder als Nachricht über den Telegram-Bot.

4Rückkanal: Der ESP32 gibt Befehle

UART funktioniert in beide Richtungen gleichzeitig (Vollduplex). Ergänze den UNO-Sketch um einen Befehls-Parser, dann kann der ESP32 – etwa auf einen Telegram-Befehl hin – eine LED oder ein Relais am UNO schalten:

// Ergaenzung im UNO-loop(): Befehle vom ESP32 verarbeiten
if (espSerial.available()) {
  String befehl = espSerial.readStringUntil('\n');
  befehl.trim();

  if (befehl == "LED:AN") {
    digitalWrite(13, HIGH);
    espSerial.println("OK:LED_AN");
  }
  else if (befehl == "LED:AUS") {
    digitalWrite(13, LOW);
    espSerial.println("OK:LED_AUS");
  }
  else {
    espSerial.println("FEHLER:UNBEKANNT");
  }
}

Mit dem Muster BEFEHL → Quittung (OK/FEHLER) merkt der ESP32 sofort, ob ein Kommando angekommen ist – die Basis für jedes zuverlässige Zwei-Board-System.

Troubleshooting