Der Serielle Monitor zur Fehlersuche
Easy · 15 min · Kostenlos
Ziel & Lerninhalt
Nutze Serial.print() als dein Live-Diagnose-Werkzeug – schneller als jeder Fehler-Rateschuss.
- Serial.begin() und Serial.print() korrekt einsetzen.
- Variablenwerte live beobachten und Fehler eingrenzen.
- Baudrate und Puffer verstehen.
Erklärung & Wissen
Basic
Wenn dein Projekt nicht so reagiert wie erwartet, stellt sich die Frage: Was denkt der Mikrocontroller gerade? Der Serielle Monitor ist das Fenster in den Programmablauf. Mit `Serial.print(wert)` schickt der Controller Text oder Zahlen über USB an den PC. Im Arduino-IDE öffnest du mit Strg+Shift+M den Monitor – dort erscheinen alle Ausgaben in Echtzeit. So siehst du sofort, ob ein Sensor 0 liefert, obwohl du 500 erwartest.
Medium
Serial.begin(9600) im setup() startet die UART-Kommunikation mit 9600 Baud (Bits pro Sekunde). Wichtig: Die Baudrate im Code und im Monitor-Fenster müssen übereinstimmen – sonst erscheinen nur Zeichensalat. Serial.print() schreibt ohne Zeilenumbruch, Serial.println() mit. Für Debugging: Mehrere Werte pro Zeile trennen mit Tabulator. `Serial.print("Wert:\t"); Serial.println(sensorVal);` erzeugt übersichtliche Spalten, die du auch im Plotter direkt grafisch sehen kannst.
Expert
UART (Universal Asynchronous Receiver Transmitter) ist die Hardware dahinter. Das Start-Bit signalisiert den Beginn eines Bytes, 8 Datenbits folgen, ein Stopp-Bit schließt ab (8N1). Der Hardware-FIFO-Puffer sammelt eingehende Bytes, bis `Serial.read()` sie abholt. Ist der Puffer voll (64 Bytes beim AVR) und die Software zu langsam, werden neue Bytes verworfen. Vorsicht: Zu viele Serial.print()-Aufrufe in zeitkritischen Loops (< 1 ms Periodendauer) blockieren den Controller, weil UART-Übertragung synchron warten kann. In diesem Fall: Ausgabe mit Timestamp und nur alle 100 ms ausgeben.
Fun Fact
UART ist über 60 Jahre alt – erfunden in den 1960ern für Fernschreiber. Moderner USB-UART-Chip auf dem Arduino Uno ist im Kern derselbe Mechanismus, nur mit USB-Hülle drumherum.
- Baudrate
- Übertragungsgeschwindigkeit in Bits pro Sekunde – muss auf beiden Seiten gleich sein. Bei 9600 Baud dauert 1 Bit genau $t = 1/9600 \approx 104\,\mu s$. Ein vollständiges Byte (Start + 8 Datenbits + Stopp = 10 Bits) braucht $1{,}04\,ms$. Bei 115200 Baud sinkt das auf $\approx 87\,\mu s$ pro Byte – 12× schneller.
- Puffergröße
- Zwischenspeicher (FIFO), der Bytes sammelt bis der Code sie liest. ATmega328-UART-Puffer: 64 Byte TX (senden) + 64 Byte RX (empfangen). Ist der Puffer voll und du rufst Serial.println() auf, wartet der Code, bis Platz frei ist. Das kann Echtzeit-Schleifen empfindlich verzögern.
- Serial Plotter
- Grafische Echtzeit-Darstellung von Zahlenwerten aus dem Seriellen Monitor. Statt text-basierter Ausgabe zeigt der Serial Plotter (Arduino IDE: Werkzeuge → Serieller Plotter) Zahlenwerte als live-Kurve. Ausgabe mehrerer Werte durch Leerzeichen getrennt auf einer Zeile erzeugt mehrere Kurven gleichzeitig – perfekt für Sensor-Kalibrierungen.
- UART-Frame
- Das genaue Bitmuster, mit dem ein Byte über die Leitung gesendet wird. Aufbau (8N1): 1 Startbit (LOW) + 8 Datenbits (LSB zuerst) + 1 Stoppbit (HIGH). 'N' steht für kein Paritätsbit. Das Stoppbit gibt dem Empfänger Zeit, den Puffer zu schreiben. Falsche Baudrate → Empfänger tastet Bits zum falschen Zeitpunkt ab → Datenmüll.
Praktischer Versuch: Sensor live beobachten und Fehler finden
Lese Sensorwerte (Poti oder frei liegender Kabel-Pin) im Seriellen Monitor und lerne, wie man damit Bugs findet.
- Stück Alufolie oder blanker Draht als Testsensor
Erstes Serial.print()
Schreibe in loop() nur: Serial.println("Hallo ProtoPeaks!"); delay(500); Lade hoch und öffne den Monitor. Du siehst die Ausgabe alle 500 ms.
Check: Serieller Monitor zeigt 'Hallo ProtoPeaks!' wiederholt.
Tipp: Strg+Shift+M öffnet den Monitor in Arduino IDE. Baudrate auf 9600 stellen.
Variablenwert ausgeben
Füge eine Zähler-Variable hinzu: `int zaehler = 0;`. In loop(): zaehler++; if(zaehler > 255) zaehler = 0; Serial.println(zaehler); delay(50);
Check: Monitor zeigt laufende Zahl von 0 bis 255.
Tipp: Serial.print() und Serial.println() können int, float, String ausgeben.
Analogwert eines floating Pin lesen
Lasse A0 offen (kein Draht verbunden). Lese analogRead(A0) und schreibe es in den Monitor. Beobachte das Rauschen. Berühre dann mit dem Finger den Pin – der Wert ändert sich durch Körperkapazität.
Check: A0-Wert springt zwischen verschiedenen Zahlen – ein floating pin 'rauscht'.
Tipp: Das Rauschen ist normal für unbeschaltete Pins – kein Fehler!
Beschriftetes Format verwenden
Ändere die Ausgabe auf: Serial.print("Pin="); Serial.print(rohWert); Serial.print("\tVolt="); Serial.println(rohWert * 5.0 / 1023.0, 2);
Check: Monitor zeigt 'Pin=xxx | Volt=x.xxV' in übersichtlichen Spalten.
Tipp: \t ist ein Tabulator-Zeichen für gleichmäßige Ausrichtung.
Serial Plotter ausprobieren
Öffne den Serial Plotter (Werkzeuge → Serieller Plotter). Gib nur die reine Zahl aus: Serial.println(analogRead(A0)). Beobachte die Live-Kurve.
Check: Kurve bewegt sich wenn du A0 berührst.
Tipp: Im Plotter nur Zahlen ausgeben, keine Texte – sonst crasht die Darstellung.
Nur USB-Verbindung nötig. A0 bleibt offen für Rausch-Demo.
// ProtoPeaks - Serieller Monitor Demo
void setup() {
Serial.begin(9600);
Serial.println("ProtoPeaks gestartet!");
}
void loop() {
int rohWert = analogRead(A0);
float volt = rohWert * 5.0 / 1023.0;
Serial.print("Pin=\t"); Serial.print(rohWert);
Serial.print("\tVolt=\t"); Serial.println(volt, 2);
delay(100);
}- Monitor zeigt Zeichensalat (z.B. ??? oder leere Boxen). — Baudrate im Monitor-Fenster stimmt nicht mit Serial.begin() überein. Beide auf 9600 stellen.
- Nichts erscheint im Monitor. — Monitor nach dem Upload öffnen (nicht davor). Oder Reset-Taste auf dem Board drücken nach Öffnen des Monitors.
Kurzzusammenfassung
Serial.print() ist das schnellste Debug-Werkzeug für den ProtoPeaks. Baudrate konsistent halten, Ausgaben beschriften, Serial Plotter für Sensorkurven nutzen. Wer den Monitor beherrscht, findet Bugs in Minuten statt Stunden.