Arduino Serieller Monitor: Baudrate, Daten senden, Plotter

Der Arduino Serielle Monitor (englisch Serial Monitor) ist das Fenster in der Arduino IDE, über das dein Board und dein Computer per USB-Kabel Text austauschen. Hier liest du die Ausgabe jeder Serial.println()-Zeile deines Sketches, und von hier schickst du Befehle zurück an das Board. Er ist der schnellste Weg, um zu sehen, welchen Wert ein Sensor gerade misst, bis zu welcher Zeile dein Programm gekommen ist oder ob ein Taster wirklich gedrückt wird, und damit das wichtigste Werkzeug zur Fehlersuche bei Arduino. Damit er funktioniert, brauchst du nur Serial.begin(9600) in deinem Code, den richtigen Port in der Board-Auswahl und im Monitor dieselbe Geschwindigkeit wie im Code.

In dieser Anleitung öffnest du zuerst den Seriellen Monitor und erfährst dann, was die Baudrate wirklich bedeutet, wie du Zahlen mit print und println dezimal, hexadezimal und binär ausgibst, wie du die Zahl der Nachkommastellen festlegst und mit snprintf saubere Zeilen baust. Mit Beispiel-Sketches, die sich wirklich kompilieren lassen, behandeln wir alle Ursachen für wirre Zeichen, den Einfluss der Zeilenende-Einstellung auf deinen Code, das Senden von Zahlen und Textbefehlen vom Computer an das Board (Serial.read, parseInt, readStringUntil), Live-Diagramme mit dem Seriellen Plotter und Debugging-Techniken, die dir das Leben leichter machen. Die letzten Abschnitte zeigen, wie sich die serielle Ausgabe auf dem ESP32 und dem Raspberry Pi Pico (mit Arduino und MicroPython) unterscheidet und wie du häufige Probleme wie einen leeren Monitor löst.

Was ist der Arduino Serielle Monitor und wie funktioniert er?

Der ATmega328P, das Herz des Arduino Uno, spricht mit der Außenwelt über eine serielle Schnittstelle namens UART: Er sendet Daten Bit für Bit auf einer Leitung (TX) und empfängt auf einer anderen (RX). Moderne Computer haben keine solche serielle Schnittstelle mehr, deshalb wandelt ein zweiter Chip auf dem Board (beim Original-Uno ein ATmega16U2, bei Nachbauten meist ein CH340) das Signal in USB um. Der Computer sieht das Board als virtuellen seriellen Port: unter Windows etwa als COM3, unter Linux als /dev/ttyACM0 oder /dev/ttyUSB0 und unter macOS mit einem Namen, der mit /dev/cu.usbmodem oder /dev/cu.usbserial beginnt. Der Serielle Monitor öffnet diesen Port, zeigt die ankommenden Bytes als Text an und schickt deine Eingaben auf demselben Weg zum Board. Standardmäßig nutzt Arduino das Format 8N1: pro Byte ein Startbit, 8 Datenbits, kein Paritätsbit und ein Stoppbit. Ein einzelnes Zeichen belegt auf der Leitung also 10 Bit; diese Zahl brauchen wir für die Geschwindigkeitsberechnungen.

So öffnest und nutzt du den Seriellen Monitor

1. Füge die Zeile Serial.begin(9600); in den setup()-Teil deines Sketches ein und lade ihn hoch. Ohne diese Zeile schreibt das Board nichts auf die serielle Schnittstelle.
2. Wähle in der Board-Auswahl in der oberen Leiste oder im Menü Werkzeuge > Port den Port, an dem dein Board hängt. Ist kein Port gewählt, zeigt der Serielle Monitor die Meldung Keine Verbindung. Wähle ein Board und einen Port, um automatisch zu verbinden. (in der englischen Oberfläche: Not connected. Select a board and a port to connect automatically.)
3. Klicke auf das Lupen-Symbol oben rechts, nutze das Menü Werkzeuge > Serieller Monitor oder drücke Strg+Umschalt+M (unter macOS Cmd+Shift+M). In der IDE 2 öffnet sich der Monitor im unteren Bereich neben der Ausgabe.
4. Wähle im Geschwindigkeitsmenü rechts im Bereich dieselbe Baudrate wie in deinem Code, in diesem Beispiel 9600. Ist die Geschwindigkeit anders, erscheinen wirre Zeichen.
5. Um Daten an das Board zu senden, tippe in das Nachrichtenfeld oben im Bereich und drücke Enter. Im Menü direkt daneben wählst du das Zeilenende; warum diese Einstellung wichtig ist, erklären wir weiter unten.
6. Mit den Schaltflächen oben rechts kannst du das automatische Scrollen anhalten (praktisch beim Lesen älterer Zeilen), Zeitstempel einschalten, die jeder Zeile die Uhrzeit deines Computers voranstellen, und die Ausgabe löschen.

In der alten Arduino IDE 1.8 öffnet sich der Serielle Monitor in einem eigenen Fenster; die Bedienelemente erfüllen dieselben Aufgaben, liegen aber an anderen Stellen: Die Kästchen für automatisches Scrollen und Zeitstempel sind unten links, die Menüs für Zeilenende und Geschwindigkeit unten rechts. Du kannst die serielle Schnittstelle auch ohne IDE beobachten: PuTTY oder CoolTerm unter Windows, der Befehl screen /dev/ttyUSB0 115200 unter Linux und macOS und arduino-cli monitor -p COM3 -c baudrate=115200 auf jedem System erledigen dieselbe Aufgabe. Merke dir eines: Ein serieller Port kann immer nur von einem Programm gleichzeitig geöffnet werden. Solange ein Python-Skript oder PuTTY den Port belegt, kannst du aus der IDE keinen Code hochladen; die Installation der IDE und den Rest ihrer Oberfläche beschreiben wir in der Anleitung Arduino IDE installieren.

Serial.begin() und Baudrate: 9600 oder 115200?

Serial.begin(geschwindigkeit) startet die serielle Schnittstelle mit der angegebenen Geschwindigkeit und wird fast immer einmal in setup() aufgerufen. Die Geschwindigkeit wird in Baud angegeben, also in Bit pro Sekunde auf der Leitung. Da jedes Zeichen 10 Bit belegt, bedeuten 9600 Baud höchstens 960 Zeichen pro Sekunde; ein einzelnes Zeichen zu senden dauert etwa 1,04 Millisekunden. Eine Zeile mit 30 Zeichen braucht bei dieser Geschwindigkeit 31 ms, und sobald du Hunderte Messwerte pro Sekunde ausgeben willst, stößt du an diese Grenze. Bei 115200 Baud dauert dieselbe Zeile nur 2,6 ms. Der Wert im Sketch und der Wert im Seriellen Monitor müssen übereinstimmen, denn es gibt kein gemeinsames Taktsignal und der Empfänger liest die Bits allein anhand der Zeit.

Der 16-MHz-Takt des Uno kann nicht jede Geschwindigkeit exakt erzeugen: 115200 Baud laufen tatsächlich mit etwa 2 % Abweichung, also mit 117647 Baud. Im Seriellen Monitor macht diese Abweichung keine Probleme, bei der Verbindung mit einem anderen Mikrocontroller über ein langes Kabel kann sie aber Fehler verursachen; dann sind 57600 oder die fehlerfrei erzeugten 250000 Baud sicherer. Wenn du gerade anfängst, nimm 9600 für Uno und Nano und 115200 für ESP32 und Pico. Verbindest du zwei Boards über TX-RX-Leitungen, muss die Geschwindigkeit auf beiden Seiten gleich sein, die GNDs müssen verbunden sein, und eine 5-V-TX-Leitung muss mit einem Spannungsteiler heruntergesetzt werden, bevor sie an einen 3,3-V-RX-Eingang (ESP32, Pico) geht. Details findest du im Artikel UART serielle Kommunikation.

Serial.print() und Serial.println(): ausgeben und formatieren

Serial.print() schreibt den übergebenen Wert und lässt den Cursor in derselben Zeile; Serial.println() hängt danach zusätzlich die Zeilenende-Zeichen (\r\n) an, sodass die nächste Ausgabe in einer neuen Zeile beginnt. Um mehrere Werte in einer Zeile anzuzeigen, gibst du die ersten Teile mit print und den letzten mit println aus. Diese Funktionen akzeptieren fast jeden Typ, etwa int, long, float, char, Text und String, und der optionale zweite Parameter legt das Format fest. Bei Ganzzahlen kannst du DEC, HEX, BIN und OCT wählen, bei Kommazahlen ist der zweite Parameter die Zahl der Nachkommastellen. Kommazahlen werden standardmäßig gerundet mit 2 Stellen ausgegeben. Im folgenden Code steht die Ausgabe jeder Zeile als Kommentar:

1// Biçimlendirme örnekleri: çıktılar yorumlarda / Formatting examples: output in the comments
2void setup() {
3  Serial.begin(9600);
4  int sayi = 78;
5  float pi = 3.14159;
6
7  Serial.println(sayi);           // 78
8  Serial.println(sayi, HEX);      // 4E
9  Serial.println(sayi, BIN);      // 1001110
10  Serial.println(sayi, OCT);      // 116
11  Serial.println(pi);             // 3.14 (varsayılan 2 basamak / 2 decimals by default)
12  Serial.println(pi, 4);          // 3.1416
13  Serial.write(65);               // A (ham bayt / raw byte)
14  Serial.println();               // yalnız satır sonu / line break only
15
16  Serial.print("Sicaklik:\t");    // \t = sekme / \t = tab
17  Serial.print(23.46, 1);         // 23.5
18  Serial.println(" C");           // Sicaklik:  23.5 C
19
20  char satir[32];
21  int saat = 9, dakika = 5;
22  snprintf(satir, sizeof(satir), "Saat %02d:%02d", saat, dakika);
23  Serial.println(satir);          // Saat 09:05
24
25  char metin[10];
26  dtostrf(pi, 6, 2, metin);       // Uno'da %f yerine / instead of %f on the Uno
27  Serial.println(metin);          // "  3.14"
28}
29
30void loop() {
31}

Statt lange Zeilen Stück für Stück auszugeben, kannst du mit snprintf() einen einzigen Text zusammensetzen: %d steht für eine Ganzzahl, %02d für eine zweistellige Ganzzahl mit führender Null, %s für Text und %lu für einen unsigned long wie millis(). Um Speicher zu sparen, unterstützt die C-Bibliothek des Uno kein %f; versuchst du, eine Kommazahl auszugeben, erscheint an ihrer Stelle ein ?. Wandle Kommazahlen deshalb zuerst mit dtostrf(zahl, breite, stellen, puffer) in Text um. Auf ESP32 und Pico kannst du direkt Serial.printf() verwenden. Der Uno hat nur 2 KB RAM; feste Texte mit dem F()-Makro zu schreiben, etwa Serial.println(F("Hallo")), hält sie im Flash statt im RAM und beugt in großen Projekten Problemen mit zu wenig Speicher vor.

Wirre Zeichen im Seriellen Monitor und ihre Lösung

Siehst du ⸮⸮⸮, � oder Haufen zufälliger Buchstaben und Symbole, kommen die Daten zwar am Computer an, werden aber falsch entschlüsselt. Da es bei serieller Kommunikation kein gemeinsames Taktsignal gibt, berechnet der Empfänger ab dem Startbit die Mitte jedes Bits anhand seiner eigenen Geschwindigkeit. Stimmt die Geschwindigkeit nicht oder läuft der Takt des Boards anders als erwartet, werden die Bits zum falschen Zeitpunkt gelesen und jedes Byte wird zu einem anderen Zeichen. Meist steckt nur eine einzige Einstellung dahinter; die Tabelle unten ordnet die häufigsten Fälle nach Symptom. Für Boards mit verschiedenen Taktoptionen wie den Pro Mini lohnt sich auch ein Blick in den Artikel Arduino Pro Mini.

Zeilenende einstellen: No Line Ending, New Line, Carriage Return, Both NL & CR

Wenn du etwas in das Nachrichtenfeld tippst und Enter drückst, sendet der Serielle Monitor nicht nur die getippten Zeichen, sondern je nach gewähltem Zeilenende noch ein oder zwei unsichtbare Zeichen dazu. Erwartet dein Code diese nicht, weil er zum Beispiel jedes ankommende Byte als Befehl behandelt, werden auch '\n' (Wert 10) und '\r' (13) als Befehle gelesen. Wartet dein Code umgekehrt auf ein Zeilenende und die Einstellung ist No Line Ending, endet die Zeile nie; readStringUntil() wartet, bis das Timeout abläuft. Die Tabelle zeigt die Bytes, die an das Board gehen, wenn du 42 tippst und Enter drückst:

Eine praktische Regel: Für Code, der zeilenweise liest, wählst du New Line und wendest auf den gelesenen Text trim() an; so funktioniert dein Code, egal welche Einstellung der Nutzer wählt. Für Befehle aus einem einzigen Zeichen wie 1, 0 oder a ist No Line Ending die sauberste Wahl. Die IDE merkt sich deine Auswahl, also prüfe sie, wenn du zu einem anderen Projekt wechselst.

Daten vom Computer an Arduino senden: Serial.read(), parseInt(), readStringUntil()

Die Bytes, die du aus dem Seriellen Monitor sendest, landen der Reihe nach im Empfangspuffer des Boards (beim Uno 64 Byte). Serial.available() sagt dir, wie viele Bytes darin warten, Serial.read() holt das nächste Byte und entfernt es aus dem Puffer, ohne Daten liefert es -1, und Serial.peek() schaut sich das nächste Byte an, ohne es zu entfernen. Denk daran, dass alles von der Tastatur als ASCII-Zeichen ankommt: Tippst du 7, erhält das Board nicht die Zahl 7, sondern 55, den Code des Zeichens '7'. Ein Beispiel für einfache Ein-Tasten-Befehle findest du im Artikel Arduino Befehle; hier geht es um mehrstellige Zahlen und Befehle aus Wörtern. Läuft der Puffer voll, gehen neu ankommende Bytes verloren; Zeitsteuerung mit millis() statt langem Warten mit delay() in loop() macht deshalb auch das serielle Lesen sicherer.

Serial.parseInt() holt die erste Ganzzahl aus den ankommenden Zeichen: Es überspringt führende Buchstaben und Leerzeichen, fügt die Ziffern zusammen und stoppt beim ersten Zeichen, das keine Ziffer ist; ein Minuszeichen versteht es auch. So wird aus dem Text "128" die Zahl 128. Für Kommazahlen erledigt Serial.parseFloat() dasselbe. Eine Eigenart dieser Funktionen musst du kennen: Kommt keine Zahl, warten sie standardmäßig 1000 ms und geben dann 0 zurück. Der klassische Fehler läuft so ab: Mit der Einstellung New Line sendest du 42, parseInt liest 42, aber das '\n' bleibt im Puffer. Im nächsten Durchlauf sieht loop(), dass available() größer als 0 ist, und ruft parseInt erneut auf, das eine Sekunde wartet und 0 zurückgibt. Ergebnis: Nach jeder Zahl kommt noch eine 0, und du findest nicht heraus, warum die LED jedes Mal eine Sekunde später ausgeht. Der Code unten löst das Problem an der Wurzel, indem er das nächste Zeichen verwirft, wenn es keine Ziffer ist, und verkürzt die Wartezeit mit setTimeout().

1// Seri Port Ekranı'ndan sayı al: LED parlaklığı 0-255
2// Read a number from the Serial Monitor: LED brightness 0-255
3const int LED_PIN = 9;   // ~9 PWM pini + 220 ohm direnç / ~9 PWM pin + 220 ohm resistor
4
5void setup() {
6  pinMode(LED_PIN, OUTPUT);
7  Serial.begin(9600);
8  Serial.setTimeout(100);   // parseInt en fazla 100 ms bekler / parseInt waits at most 100 ms
9  Serial.println(F("0-255 arasi bir sayi yaz / Type a number from 0 to 255"));
10}
11
12void loop() {
13  if (Serial.available() > 0) {
14    char c = Serial.peek();               // sıradakine bak, silme / look at the next byte, keep it
15    if (isDigit(c) || c == '-') {
16      int deger = Serial.parseInt();      // "128" -> 128
17      deger = constrain(deger, 0, 255);   // aralığın dışına çıkma / stay within range
18      analogWrite(LED_PIN, deger);
19      Serial.print(F("Parlaklik / Brightness: "));
20      Serial.println(deger);
21    } else {
22      Serial.read();                      // '\r', '\n' ve harfleri at / drop '\r', '\n' and letters
23    }
24  }
25}

Für Befehle aus Wörtern liest du am einfachsten die ganze Zeile als String ein. Serial.readStringUntil('\n') liest, bis ein '\n' kommt, verwirft das Zeilenende-Zeichen und gibt den Rest zurück. Steht die Einstellung auf Both NL & CR, bleibt am Ende des Textes ein '\r' übrig, aus deinem Befehl "on" wird "on\r" und der Vergleich schlägt fehl. Wende deshalb sofort trim() auf die Zeile an: Es entfernt führende und nachfolgende Leerzeichen sowie '\r'- und '\n'-Zeichen. toLowerCase() macht ON, On und on gleich. Das Beispiel unten versteht die Befehle on, off, blink 250 und status; nutze den Seriellen Monitor mit 115200 Baud und New Line. Weil es mit millis() statt delay() blinkt, reagiert es jederzeit sofort auf einen neuen Befehl.

1// Metin komutları: on, off, blink 250, status
2// Text commands: on, off, blink 250, status
3const int LED_PIN = LED_BUILTIN;   // Uno'da pin 13 / pin 13 on the Uno
4bool ledAcik = false;              // LED'in şu anki durumu / current LED state
5bool yanipSon = false;             // yanıp sönme modu / blink mode
6unsigned long aralik = 500;        // yanıp sönme aralığı (ms) / blink interval (ms)
7unsigned long sonDegisim = 0;      // LED'in son değiştiği an / last time the LED changed
8
9void ledYaz(bool acik) {
10  ledAcik = acik;
11  digitalWrite(LED_PIN, acik ? HIGH : LOW);
12}
13
14void komutuIsle(String komut) {
15  if (komut == "on") {
16    yanipSon = false;
17    ledYaz(true);
18    Serial.println(F("LED: on"));
19  } else if (komut == "off") {
20    yanipSon = false;
21    ledYaz(false);
22    Serial.println(F("LED: off"));
23  } else if (komut.startsWith("blink")) {
24    long ms = komut.substring(5).toInt();       // "blink 250" -> 250
25    aralik = (ms >= 50) ? ms : 500;             // çok küçükse 500 ms / fall back to 500 ms
26    yanipSon = true;
27    Serial.print(F("Blink (ms): "));
28    Serial.println(aralik);
29  } else if (komut == "status") {
30    Serial.print(F("LED: "));
31    Serial.print(ledAcik ? F("on") : F("off"));
32    Serial.print(F(", blink: "));
33    Serial.println(yanipSon ? F("yes") : F("no"));
34  } else {
35    Serial.print(F("Bilinmeyen komut / Unknown command: "));
36    Serial.println(komut);
37  }
38}
39
40void setup() {
41  pinMode(LED_PIN, OUTPUT);
42  Serial.begin(115200);
43  Serial.setTimeout(100);   // satır sonu gelmezse 100 ms sonra bırak / give up after 100 ms without a line ending
44  Serial.println(F("Komutlar / Commands: on, off, blink 250, status"));
45}
46
47void loop() {
48  if (Serial.available() > 0) {
49    String komut = Serial.readStringUntil('\n');   // Enter'a kadar oku / read up to Enter
50    komut.trim();                                  // '\r' ve boşlukları sil / strip '\r' and spaces
51    komut.toLowerCase();                           // ON ile on aynı olsun / treat ON like on
52    if (komut.length() > 0) {
53      komutuIsle(komut);
54    }
55  }
56
57  if (yanipSon && millis() - sonDegisim >= aralik) {   // delay() olmadan yanıp sön / blink without delay()
58    sonDegisim = millis();
59    ledYaz(!ledAcik);
60  }
61}

Live-Diagramme mit dem Seriellen Plotter

Der Serielle Plotter (englisch Serial Plotter) verwandelt die Zahlen von der seriellen Schnittstelle in ein Live-Liniendiagramm; du öffnest ihn über das Wellen-Symbol oben rechts in der IDE oder über das Menü Werkzeuge > Serieller Plotter. Das Format ist sehr einfach: Trenne die Werte einer Zeile mit Kommas, Leerzeichen oder Tabs und beende die Zeile mit println. Jede Zeile wird zu einem Zeitschritt im Diagramm, jeder Wert in der Zeile zu einer eigenen farbigen Linie. Setzt du im Format label:wert einen Namen vor die Werte, tragen die Linien diesen Namen und lassen sich über die Kästchen oberhalb des Diagramms einzeln aus- und einblenden; ohne Label heißen die Linien value 1, value 2 und so weiter. Auch hier muss das Geschwindigkeitsmenü zum Code passen. Der Code unten zeichnet den Rohwert an A0 und seine geglättete Version in dasselbe Diagramm:

1// Seri Çizici: ham değer ve yumuşatılmış değer / Serial Plotter: raw and smoothed value
2const int SENSOR_PIN = A0;   // potansiyometre ya da LDR bölücü çıkışı / potentiometer or LDR divider output
3float yumusak = 0;           // üstel ortalama / exponential moving average
4
5void setup() {
6  Serial.begin(115200);
7}
8
9void loop() {
10  int ham = analogRead(SENSOR_PIN);           // 0-1023
11  yumusak = yumusak * 0.9 + ham * 0.1;        // yeni ölçümün payı %10 / the new reading weighs 10%
12
13  Serial.print("Min:0,Max:1023,");            // dikey ekseni sabitler / keeps the y-axis fixed
14  Serial.print("Ham:");
15  Serial.print(ham);
16  Serial.print(",Yumusak:");
17  Serial.println(yumusak);                    // satırı bitir: bir ölçüm / end the line: one sample
18  delay(20);                                  // saniyede yaklaşık 50 satır / about 50 lines per second
19}

• Skala festlegen: Der Serielle Plotter passt die senkrechte Achse ständig an die ankommenden Werte an, deshalb wirken kleine Schwankungen riesig. Zwei konstante Werte wie Min:0,Max:1023, in jeder Zeile halten die Achse fest.
• Keine Leerzeichen in Labels: Da Leerzeichen und Kommas als Trenner gelten, wird "Raum Temp:24" in zwei Teile zerlegt; nimm Namen mit Unterstrich wie Raum_Temp.
• Nur Labels und Zahlen in der Zeile: Einheiten und Beschreibungen wie "Temp 24 C" bringen das Diagramm durcheinander; gib Beschreibungen für den Seriellen Monitor in getrenntem Code aus.
• Senderate anpassen: delay(20) bedeutet etwa 50 Zeilen pro Sekunde. Sendest du zu schnell, rauscht das Diagramm in einem Augenblick davon; sendest du zu langsam, sieht die Linie wie eine Treppe aus.
• Den Filter mit eigenen Augen sehen: Rohwert und Mittelwert im selben Diagramm zeigen sofort, wie stark ein Filter das Rauschen verringert; Methoden findest du im Artikel Sensordaten filtern.
• Zum Aufzeichnen ein anderes Werkzeug nutzen: Der Serielle Plotter speichert keine Daten in eine Datei. Für lange Messungen gibst du die Werte als CSV-Zeilen aus und überträgst sie nach Excel oder liest sie mit Python ein.

Debugging-Techniken mit dem Seriellen Monitor

Der Arduino Uno hat keinen Debugger, mit dem du deinen Code Schritt für Schritt ausführen kannst; diese Aufgabe übernimmt der Serielle Monitor. Wild im Code verstreute print-Zeilen werden jedoch schnell zu einem unlesbaren Textberg. Diese Gewohnheiten helfen dir, Fehler viel schneller zu finden:

• Zuerst eine Meldung aus setup() ausgeben: Siehst du die Zeile "Started" bei jedem Start genau einmal, läuft das Board. Wiederholt sich die Zeile ständig, resettet das Board immer wieder und das Problem liegt eher bei der Stromversorgung als im Code; siehe die Anleitung Arduino startet ständig neu.
• Werte mit Namen ausgeben: Statt nur 512 zu schreiben, gib temp=24.5 feuchte=40 aus; dann musst du später nicht überlegen, welche Zahl wozu gehört.
• Markieren, wo du bist: Friert das Programm irgendwo ein, setze kurze Marker wie A, B, C vor die wichtigen Schritte. Der letzte Marker auf dem Bildschirm zeigt, wo das Programm hängt.
• Bei Änderung ausgeben, nicht in jedem Durchlauf: loop() läuft Tausende Male pro Sekunde. In jedem Durchlauf auszugeben überflutet den Bildschirm und bremst das Programm; gib einen Wert nur aus, wenn er sich ändert, oder einmal pro Sekunde mit millis().
• Zeit messen: Um zu sehen, wie lange ein Vorgang dauert, speichere den Wert von micros() davor und danach und gib die Differenz aus. So erwischst du eine langsame Sensorabfrage oder eine lange Schleife.
• Nicht in Interrupts ausgeben: Serielle Ausgabe braucht Zeit; Serial.print in einer Interrupt-Funktion macht sie unnötig lang und kann dazu führen, dass du andere Ereignisse verpasst. Setz im Interrupt nur eine Merker-Variable und erledige die Ausgabe in loop(); Details im Artikel Arduino Interrupt.
• Debug-Zeilen an einen Schalter hängen: Mit den Makros unten entfernst du sämtliche Debug-Ausgaben vollständig aus dem Code, indem du DEBUG auf 0 setzt; im fertigen Projekt sparst du so Flash-Speicher und Zeit.

1// Hata ayıklama makroları: tek satırla aç ya da kapat
2// Debug macros: switch all debug output on or off with one line
3#define DEBUG 1                  // 0 yaparsan debug satırları koddan çıkar / set to 0 to strip debug lines
4
5#if DEBUG
6  #define DBG(x)   Serial.print(x)
7  #define DBGLN(x) Serial.println(x)
8#else
9  #define DBG(x)
10  #define DBGLN(x)
11#endif
12
13const int SENSOR_PIN = A0;
14const int ESIK = 800;            // uyarı eşiği / warning threshold
15bool esikUstunde = false;        // son durum / last state
16unsigned long sonRapor = 0;
17unsigned long turSayisi = 0;     // saniyedeki loop() turu / loop() passes per second
18
19void setup() {
20  Serial.begin(115200);
21  DBGLN(F("Basladi / Started"));
22}
23
24void loop() {
25  turSayisi++;
26  int deger = analogRead(SENSOR_PIN);
27
28  bool simdi = deger > ESIK;
29  if (simdi != esikUstunde) {          // yalnız değişince yaz / print only on change
30    esikUstunde = simdi;
31    DBG(F("[esik / threshold] "));
32    DBG(simdi ? F("ustunde / above") : F("altinda / below"));
33    DBG(F(", deger / value = "));
34    DBGLN(deger);
35  }
36
37  if (millis() - sonRapor >= 1000) {   // saniyede bir özet / one summary per second
38    sonRapor = millis();
39    DBG(F("t = "));
40    DBG(sonRapor);
41    DBG(F(" ms, tur/s / loops/s = "));
42    DBGLN(turSayisi);
43    turSayisi = 0;
44  }
45}

Denk daran, dass serielle Ausgabe ihren Preis hat. Auch der Sendepuffer des Uno ist 64 Byte groß; ist er voll, wartet Serial.print(), bis wieder Platz ist, und loop() wird langsamer. Das kannst du mit dem Durchlaufzähler im Code oben selbst messen: Fügst du eine 25 Zeichen lange Zeile hinzu, die in jedem Durchlauf ausgegeben wird, sinkt das Programm bei 9600 Baud auf etwa vierzig Durchläufe pro Sekunde, während Ausgabe nur bei Änderung Tausende erhält. Willst du sicher sehen, was das Board kurz vor dem Einfrieren oder Reset ausgegeben hat, rufe nach der kritischen Zeile Serial.flush() auf; es wartet, bis alles im Puffer gesendet ist. In komplexeren Programmen macht es die Fehlersuche viel leichter, auf eine Zustandsmaschine umzustellen und nur bei einem Zustandswechsel eine einzige Zeile auszugeben.

Serielle Ausgabe auf dem ESP32

Auf ESP32-DevKit-Boards ist Serial der UART0 an GPIO 1 (TX) und GPIO 3 (RX), der über den CP2102- oder CH340-Chip auf dem Board mit USB verbunden ist. Üblich sind 115200 Baud, denn auch das ROM im Chip gibt beim Start Zeilen wie rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT) mit dieser Geschwindigkeit aus; lässt du den Monitor auf 115200, sind auch diese Zeilen lesbar. Der Arduino-Core für den ESP32 bietet Serial.printf() und unterstützt Kommazahlen mit %f. Die zusätzlichen Schnittstellen Serial1 und Serial2 lassen sich beliebigen Pins zuweisen; beim Anschluss eines Moduls ist Serial2 an GPIO 16 und 17 üblich. Bleibt der Serielle Monitor bei Boards mit eingebautem USB wie dem ESP32-S3 und ESP32-C3 leer, stell Werkzeuge > USB CDC On Boot auf Enabled. Um die eigenen Warnungen des Cores zu sehen, wählst du im Menü Werkzeuge > Core Debug Level Error, Warn, Info, Debug oder Verbose, und in deinem eigenen Code kannst du mit den Makros log_e, log_w und log_i Protokolleinträge mit Datei- und Zeilenangabe ausgeben.

1// ESP32: Serial (USB), Serial2 (GPIO16/17), printf ve log
2// ESP32: Serial (USB), Serial2 (GPIO16/17), printf and logging
3const int POT_PIN = 34;              // ADC1, yalnız giriş pini / ADC1, input-only pin
4unsigned long sonYazdirma = 0;
5
6void setup() {
7  Serial.begin(115200);                       // açılış mesajlarıyla aynı hız / same rate as the boot messages
8  delay(500);
9  Serial2.begin(9600, SERIAL_8N1, 16, 17);    // RX = GPIO16, TX = GPIO17
10
11  Serial.printf("Model: %s, CPU: %lu MHz\n", ESP.getChipModel(), (unsigned long)ESP.getCpuFreqMHz());
12  Serial.printf("Bos RAM / Free heap: %lu bayt / bytes\n", (unsigned long)ESP.getFreeHeap());
13  log_i("Core Debug Level en az Info ise gorunur / shown when Core Debug Level is Info or higher");
14}
15
16void loop() {
17  while (Serial2.available() > 0) {           // Serial2'den geleni USB'ye aktar / forward Serial2 data to USB
18    Serial.write(Serial2.read());
19  }
20
21  if (millis() - sonYazdirma >= 1000) {       // delay() yok, tampon taşmaz / no delay(), no buffer overflow
22    sonYazdirma = millis();
23    float volt = analogReadMilliVolts(POT_PIN) / 1000.0;          // kalibre gerilim / calibrated voltage
24    Serial.printf("t=%lu ms, GPIO34=%.2f V\n", millis(), volt);   // ESP32'de %f çalışır / %f works on ESP32
25  }
26}

Bei WLAN-Verbindungsproblemen, unerwarteten Resets und Guru-Meditation-Fehlern ist der Serielle Monitor die erste Anlaufstelle: Fehlerart, Reset-Grund und Backtrace-Zeilen erscheinen hier. Wie du diese Meldungen deutest, erklären wir in den Anleitungen ESP32 Brownout und Guru Meditation und ESP32 verbindet sich nicht mit dem WLAN. Nutzt du den ESP32 zum ersten Mal, beginne mit dem Artikel Was ist der ESP32?.

Serielle Ausgabe auf dem Raspberry Pi Pico: Arduino und MicroPython

Der Raspberry Pi Pico hat keinen USB-Seriell-Brückenchip; der RP2040 steuert USB selbst und meldet sich am Computer direkt als serieller Port (USB CDC). Im Arduino-Pico-Core von Earle Philhower ist Serial dieser USB-Port, und weil die Daten mit USB-Geschwindigkeit fließen, wird der Geschwindigkeitswert in Serial.begin() ignoriert. Das hat zwei Folgen: Welche Geschwindigkeit du im Monitor wählst, spielt keine Rolle mehr, aber das Board resettet beim Öffnen des Seriellen Monitors nicht wie ein Uno. Die ersten Meldungen aus setup() sind schon gesendet und verloren, bis du den Monitor öffnest; warte deshalb wie unten gezeigt kurz darauf, dass der Computer den Port öffnet. Dasselbe gilt für ATmega32U4-Boards wie Leonardo, Micro und Pro Micro. Den echten UART des Pico an den Pins GP0 und GP1 nutzt du unter dem Namen Serial1.

1// Raspberry Pi Pico (Arduino-Pico çekirdeği): USB seri port
2// Raspberry Pi Pico (Arduino-Pico core): USB serial port
3void setup() {
4  Serial.begin(115200);                  // USB'de hız değeri önemsiz / the baud value is ignored over USB
5  unsigned long baslangic = millis();
6  while (!Serial && millis() - baslangic < 3000) {
7    delay(10);                           // port açılana kadar en çok 3 sn bekle / wait up to 3 s for the port
8  }
9  Serial1.begin(9600);                   // UART0: GP0 = TX, GP1 = RX
10  Serial.println("Pico hazir / Pico ready");
11}
12
13void loop() {
14  Serial.print("Sicaklik / Temperature (C): ");
15  Serial.println(analogReadTemp(), 1);   // dahili sensör, yaklaşık / internal sensor, approximate
16  Serial1.println(millis());             // aynı anda UART0'a da yaz / also write to UART0
17  delay(1000);
18}

In MicroPython ist alles noch einfacher: Alles, was du mit print() ausgibst, geht per USB an den Computer und erscheint in der Shell von Thonny; eine Baudrate gibt es nicht einzustellen. Öffnest du in Thonny das Menü View > Plotter, werden die Zahlen in den Zeilen wie beim Seriellen Plotter zu einem Live-Diagramm. Um Daten vom Computer zu empfangen, kannst du input() verwenden, aber input() hält das Programm an, bis eine Zeile kommt. Um weiter zu messen und trotzdem auf Befehle zu hören, prüfst du wie unten mit select.poll(), ob auf stdin Daten warten; tippe einfach on oder off in die Shell und drücke Enter. Den Pico und die Installation von MicroPython beschreiben wir im Artikel Was ist der Raspberry Pi Pico?.

1# Pico MicroPython: print() ile yazdır, programı durdurmadan komut al
2# Pico MicroPython: print with print(), read commands without blocking
3import sys
4import select
5import time
6from machine import ADC, Pin
7
8led = Pin(25, Pin.OUT)            # Pico'da dahili LED; Pico W'de Pin("LED") / onboard LED; Pin("LED") on Pico W
9sensor = ADC(4)                   # dahili sıcaklık sensörü / internal temperature sensor
10poll = select.poll()
11poll.register(sys.stdin, select.POLLIN)
12
13while True:
14    volt = sensor.read_u16() * 3.3 / 65535
15    sicaklik = 27 - (volt - 0.706) / 0.001721
16    print("Sicaklik:{:.1f}".format(sicaklik))    # Thonny Plotter da çizer / Thonny's Plotter can graph it
17    if poll.poll(0):                              # bekleyen veri var mı? / is input waiting?
18        komut = sys.stdin.readline().strip()      # satırı al, boşlukları sil / read the line, strip spaces
19        if komut == "on":
20            led.value(1)
21        elif komut == "off":
22            led.value(0)
23        print("Komut / Command:", komut)
24    time.sleep(1)

Serieller Monitor leer, Port belegt: häufige Fehler und Lösungen

Projektideen mit serieller Kommunikation

• LED und Relais vom Computer aus steuern: Erweitere den Befehlsparser aus diesem Artikel, um ein Relais oder einen Motor mit den Befehlen on, off und blink zu steuern.
• Sensor-Datenlogger: Gib Temperatur und Luftfeuchtigkeit als kommagetrennte CSV-Zeilen aus und mach daraus am Computer Tabelle und Diagramm; der DHT11 ist ein guter Sensor für den Anfang.
• Live-Lichtdiagramm: Beobachte den Wert eines LDR oder Potentiometers im Seriellen Plotter und sieh die Wirkung des Filters im selben Diagramm.
• Desktop-Oberfläche mit Python: Lies die Daten des Arduino mit einem Python-Programm ein und baue eine Oberfläche mit Schaltflächen; Details im Artikel Arduino Python serielle Kommunikation.
• Modul-Teststation: Auch GPS-, Bluetooth- und GSM-Module nutzen eine serielle Schnittstelle; leite die Rohdaten des Moduls an den Seriellen Monitor weiter und prüfe, ob es funktioniert (HC-05, NEO-6M GPS).
• Ausprobieren ohne Board: Hast du gerade kein Board zur Hand, bietet auch Tinkercad einen Seriellen Monitor; den Code aus diesem Artikel kannst du in einer Tinkercad-Simulation laufen lassen.

Sobald du sicher mit dem Seriellen Monitor umgehst, wird Fehlersuche bei Arduino vom Raten zum Messen. Als nächsten Schritt lies den Artikel UART serielle Kommunikation, um zwei Boards über TX und RX miteinander sprechen zu lassen, und den Artikel USB-TTL-Wandler, um Boards ohne USB zu programmieren. In der BlueGrays-App findest du Projekte wie die Ausgabe der mit einem HC-SR04 gemessenen Entfernung im Seriellen Monitor, das Messen der Lichtstärke mit einem LDR, Temperatur und Luftfeuchtigkeit mit einem DHT11 und die Verbindung zweier Arduinos über eine serielle Leitung, Schritt für Schritt mit Schaltplänen und fertigem Code.