Arduino Serial Monitor: baudrate, data versturen, Serial Plotter
Zo gebruik je de Arduino Serial Monitor: Serial.begin en baudrate, onleesbare tekens oplossen, regeleinden, parseInt, Serial Plotter, voorbeelden voor ESP32 en Pico.
De Arduino Serial Monitor is het venster in de Arduino IDE waarmee je board en je computer tekst uitwisselen via de USB-kabel. Hier lees je de uitvoer van elke Serial.println()-regel in je sketch en hier typ je commando's die naar het board teruggaan. Het is de snelste manier om te zien wat een sensor nu meet, hoe ver je programma is gekomen of een knop echt wordt ingedrukt, en dat maakt het het belangrijkste debugtool in de Arduino-wereld. Om het te gebruiken heb je alleen Serial.begin(9600) in je code nodig, de juiste poort geselecteerd in de boardselector en dezelfde snelheid in de monitor als in je code.
In deze gids open je eerst de Serial Monitor en zie je daarna wat de baudrate echt betekent, hoe je getallen decimaal, hexadecimaal en binair afdrukt met print en println, hoe je het aantal decimalen bepaalt en hoe je nette regels bouwt met snprintf. Aan de hand van voorbeeldsketches die echt compileren behandelen we alle oorzaken van onleesbare tekens, hoe de instelling voor het regeleinde je code beïnvloedt, hoe je getallen en tekstcommando's van de computer naar het board stuurt (Serial.read, parseInt, readStringUntil), hoe je live grafieken tekent met de Serial Plotter en welke debugtechnieken je leven makkelijker maken. De laatste delen laten zien hoe seriële uitvoer verschilt op de ESP32 en de Raspberry Pi Pico (met zowel Arduino als MicroPython) en hoe je veelvoorkomende problemen zoals een lege monitor oplost.

Wat is de Arduino Serial Monitor en hoe werkt hij?
De ATmega328P, het brein van de Arduino Uno, praat met de buitenwereld via een seriële communicatie-eenheid die een UART heet: die verstuurt data bit voor bit over één lijn (TX) en ontvangt over een andere (RX). Moderne computers hebben dit soort seriële poort niet meer, dus zet een tweede chip op het board (een ATmega16U2 op de originele Uno, meestal een CH340 op klonen) het signaal om naar USB. De computer ziet het board als een virtuele seriële poort: zoiets als COM3 op Windows, /dev/ttyACM0 of /dev/ttyUSB0 op Linux en een naam die begint met /dev/cu.usbmodem of /dev/cu.usbserial op macOS. De Serial Monitor opent deze poort, toont de binnenkomende bytes als tekst en stuurt wat je typt op dezelfde manier terug naar het board. Standaard gebruikt Arduino het 8N1-formaat: per byte één startbit, 8 databits, geen pariteitsbit en één stopbit. Eén teken neemt dus 10 bits in beslag op de lijn; dat getal gebruiken we in de snelheidsberekeningen.
| Kenmerk | Arduino Uno | ESP32 DevKit | Raspberry Pi Pico |
|---|---|---|---|
| USB-verbinding | ATmega16U2- of CH340-brugchip | CP2102- of CH340-brugchip | De eigen USB van de RP2040 (USB CDC) |
| Seriële pins | D0 (RX), D1 (TX) | GPIO 3 (RX), GPIO 1 (TX) | Geen pins, rechtstreeks via USB |
| Extra hardwarematige seriële poorten | Geen (softwarematig met SoftwareSerial) | Serial1 en Serial2 (Serial2 wordt vaak gebruikt op GPIO 16 RX, GPIO 17 TX) | Serial1 (GP0 TX, GP1 RX), Serial2 (GP8 TX, GP9 RX) |
| Gangbare snelheid | 9600 baud | 115200 baud | Niet van belang, draait op USB-snelheid |
| Reset wanneer de monitor opent | Ja (DTR-lijn) | Hangt af van board en programma | Nee |
| Serial.printf() | Niet beschikbaar, gebruik snprintf | Beschikbaar | Beschikbaar |

De Serial Monitor openen en gebruiken
- Voeg de regel Serial.begin(9600); toe aan het setup()-gedeelte van je sketch en upload die. Zonder deze regel schrijft het board niets naar de seriële poort.
- Selecteer de poort waarop je board is aangesloten in de boardselector in de bovenbalk of in het menu Tools › Port. Als er geen poort is geselecteerd, toont de Serial Monitor de waarschuwing Not connected. Select a board and a port to connect automatically.
- Klik op het vergrootglas rechtsboven, gebruik het menu Tools › Serial Monitor of druk op Ctrl+Shift+M (Cmd+Shift+M op macOS). In IDE 2 opent de monitor in het onderste paneel, naast het tabblad Output.
- Kies in het snelheidsmenu rechts van het paneel dezelfde baudrate als in je code; in dit voorbeeld 9600. Is de snelheid anders, dan stort er een stroom onleesbare tekens over het scherm.
- Om data naar het board te sturen typ je in het berichtvak bovenaan het paneel en druk je op Enter. Kies het regeleinde in het menu er direct naast; hieronder leggen we uit waarom deze instelling ertoe doet.
- Met de knoppen rechtsboven kun je autoscroll pauzeren (handig om oudere regels te lezen), tijdstempels aanzetten die de tijd van je computer vooraan elke regel zetten en de uitvoer wissen.
In de oude Arduino IDE 1.8 opent de Serial Monitor in een apart venster; de bediening doet hetzelfde, maar zit op andere plekken: de selectievakjes voor autoscroll en tijdstempel staan linksonder, de menu's voor regeleinde en snelheid rechtsonder. Je kunt de seriële poort ook zonder de IDE bekijken: PuTTY of CoolTerm op Windows, het commando screen /dev/ttyUSB0 115200 op Linux en macOS en arduino-cli monitor -p COM3 -c baudrate=115200 op elk systeem doen hetzelfde. Houd één ding in gedachten: een seriële poort kan maar door één programma tegelijk worden geopend. Zolang een Python-script of PuTTY de poort vasthoudt, kun je geen code uploaden vanuit de IDE; de installatie van de IDE en de rest van de interface behandelden we in de gids Arduino IDE installeren.
Serial.begin() en baudrate: 9600 of 115200?
Serial.begin(speed) start de seriële poort op de opgegeven snelheid en wordt bijna altijd één keer aangeroepen in setup(). De snelheid wordt opgegeven in baud, het aantal bits dat per seconde over de lijn gaat. Omdat elk teken 10 bits kost, betekent 9600 baud maximaal 960 tekens per seconde; het versturen van één teken duurt ongeveer 1,04 milliseconde. Een regel van 30 tekens duurt bij deze snelheid 31 ms, dus zodra je honderden metingen per seconde wilt afdrukken, loop je tegen deze grens aan. Bij 115200 baud duurt dezelfde regel maar 2,6 ms. De waarde in de sketch en die in de Serial Monitor moeten overeenkomen, want er is geen gedeeld kloksignaal en de ontvanger leest de bits puur op timing.
| Baudrate | Tekens per seconde | Tijd per teken | Waar wordt het gebruikt? |
|---|---|---|---|
| 9600 | 960 | 1,04 ms | Arduino-voorbeelden; standaard voor modules zoals de HC-05 en NEO-6M gps |
| 57600 | 5760 | 174 µs | Uploadsnelheid van Nano's met de oude bootloader, sommige modules |
| 74880 | 7488 | 134 µs | Bootmeldingen van de ESP8266 |
| 115200 | 11520 | 87 µs | ESP32, Pico en snel debuggen; uploadsnelheid van de nieuwe Uno-bootloader |
| 250000 | 25000 | 40 µs | Snelle datalogging; wordt door de 16 MHz-klok van de Uno foutloos gegenereerd |
| 1000000 | 100000 | 10 µs | Zeer snelle gegevensoverdracht; vraagt om een korte kabel |
De 16 MHz-klok van de Uno kan niet elke snelheid exact maken: 115200 baud loopt in werkelijkheid ongeveer 2% af, op 117647 baud. Die afwijking geeft geen problemen in de Serial Monitor, maar kan bij communicatie met een andere microcontroller over een lange kabel tot fouten leiden; in zulke gevallen is 57600 of 250000 baud, dat foutloos wordt gegenereerd, veiliger. Begin je net, gebruik dan 9600 voor de Uno en Nano en 115200 voor de ESP32 en Pico. Verbind je twee boards met TX-RX-draden, dan moet de snelheid aan beide kanten gelijk zijn, moeten de GND's gedeeld worden en moet een TX-lijn van 5 V met een spanningsdeler omlaag worden gebracht voordat hij een RX-ingang van 3,3 V bereikt (ESP32, Pico). De details staan in het artikel UART seriële communicatie.
Serial.print() en Serial.println(): afdrukken en opmaken
Serial.print() schrijft de waarde die je meegeeft en laat de cursor op dezelfde regel staan; Serial.println() voegt daarna ook de regeleindetekens (\r\n) toe, zodat de volgende uitvoer op een nieuwe regel begint. Om meerdere waarden op één regel te tonen schrijf je de eerste delen met print en het laatste met println. Deze functies accepteren bijna elk type, zoals int, long, float, char, tekst en String, en de optionele tweede parameter bepaalt het formaat. Voor gehele getallen kun je kiezen uit DEC, HEX, BIN en OCT, terwijl de tweede parameter bij kommagetallen het aantal decimalen is. Floats worden standaard afgedrukt met 2 decimalen, afgerond. In de code hieronder hebben we de uitvoer van elke regel als commentaar geschreven:
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}| Code | Wat de Serial Monitor toont | Opmerking |
|---|---|---|
| Serial.print(78); | 78 | Decimaal (DEC) is de standaard |
| Serial.print(78, HEX); | 4E | Hexadecimaal; voor adressen, kleuren en bytewaarden |
| Serial.print(78, BIN); | 1001110 | Binair; voorloopnullen worden niet afgedrukt |
| Serial.print(3.14159); | 3.14 | Floats hebben standaard 2 decimalen |
| Serial.print(3.14159, 4); | 3.1416 | 4 decimalen, afgerond |
| Serial.write(65); | A | Stuurt ASCII-teken nummer 65, niet het getal |
| Serial.print('A'); | A | Het type char wordt als teken afgedrukt |
| Serial.print(5e9); | ovf | Op de Uno kunnen floats boven ongeveer 4,29 miljard niet worden afgedrukt |
In plaats van lange regels stukje voor stukje af te drukken, kun je één string opbouwen met snprintf(): %d is een geheel getal, %02d een geheel getal van twee cijfers met voorloopnul, %s tekst en %lu een unsigned long zoals millis(). Om geheugen te besparen ondersteunt de C-bibliotheek op de Uno %f niet; probeer je een float af te drukken, dan zie je op die plek een ?. Zet floats dus eerst om naar tekst met dtostrf(getal, breedte, decimalen, buffer). Op de ESP32 en Pico kun je Serial.printf() rechtstreeks gebruiken. De Uno heeft maar 2 KB RAM; vaste tekst schrijven met de F()-macro, zoals in Serial.println(F("Hello")), houdt die in flash in plaats van in RAM en voorkomt problemen met te weinig geheugen in grote projecten.
Onleesbare tekens in de Serial Monitor en hoe je ze oplost
Zie je ⸮⸮⸮, � of hopen willekeurige letters en symbolen, dan komt de data wel bij de computer aan, maar wordt hij verkeerd gedecodeerd. Omdat seriële communicatie geen gedeeld kloksignaal heeft, berekent de ontvanger het midden van elke bit uit zijn eigen snelheid, te beginnen op het moment dat hij het startbit ziet. Is de snelheid verkeerd, of klopt de klok van het board niet, dan worden de bits op de verkeerde momenten bemonsterd en wordt elke byte een ander teken. De oorzaak is meestal één enkele instelling; de tabel hieronder somt de meest voorkomende gevallen op per symptoom. Voor boards met andere klokopties, zoals de Pro Mini, lees je ook het artikel Arduino Pro Mini.
| Symptoom | Oorzaak | Oplossing |
|---|---|---|
| Onleesbaar van begin tot eind | De snelheid van de Serial Monitor verschilt van de Serial.begin()-waarde | Kies de snelheid uit je code in het menu rechts |
| Alleen één regel bij het opstarten is onleesbaar, de rest is goed | De ESP8266 op 74880 of de ESP32 op 115200 baud drukt zijn eigen bootmelding af | Dat is normaal; zet de monitor op die snelheid als je het wilt lezen |
| Uitvoer op een Pro Mini is altijd onleesbaar | Er is een board van 5 V / 16 MHz gekozen voor een van 3,3 V / 8 MHz, dus de echte snelheid is gehalveerd | Kies de echte klok van het board in het menu Tools › Processor |
| Willekeurige tekens worden door normale tekst gemengd | Een module op de pins D0/D1 praat ook op de lijn | Sluit de module met SoftwareSerial aan op andere pins |
| Vreemde symbolen in plaats van getallen | Serial.write(getal) stuurt het getal als ruwe byte | Gebruik Serial.print() om het getal als tekst af te drukken |
| Data tussen twee boards is beschadigd | Geen gedeelde GND, een lange kabel of verschillende snelheden | Verbind de GND's, kort de kabel in, verlaag de snelheid |
| Dezelfde onleesbare regel blijft verschijnen en het board herstart | De voeding is onvoldoende en het board blijft resetten | Controleer voeding en kabel, voed de belasting apart |
Instelling voor het regeleinde: No Line Ending, New Line, Carriage Return, Both NL & CR
Als je in het berichtvak typt en op Enter drukt, stuurt de Serial Monitor niet alleen de tekens die je typte, maar ook één of twee onzichtbare tekens, afhankelijk van het regeleinde dat je hebt gekozen. Verwacht je code die niet, bijvoorbeeld als hij elke binnenkomende byte als commando behandelt, dan worden '\n' (waarde 10) en '\r' (13) ook als commando's gelezen. Wacht je code daarentegen op een regeleinde en staat de instelling op No Line Ending, dan eindigt de regel nooit; readStringUntil() wacht tot de timeout verloopt. De tabel hieronder toont de bytes die naar het board gaan als je 42 typt en op Enter drukt:
| Betekenis | Naam in de IDE | Toegevoegd teken | Verstuurde bytes voor 42 |
|---|---|---|---|
| Er wordt niets toegevoegd | No Line Ending | Geen | 52, 50 |
| Nieuwe regel (LF) | New Line | \n (LF, 10) | 52, 50, 10 |
| Carriage return (CR) | Carriage Return | \r (CR, 13) | 52, 50, 13 |
| Beide (CR + LF) | Both NL & CR | \r\n (13, 10) | 52, 50, 13, 10 |
Een praktische regel: kies voor code die regel voor regel leest New Line en pas trim() toe op de gelezen tekst; zo werkt je code welke instelling de gebruiker ook kiest. Voor commando's van één teken, zoals 1, 0 of a, is No Line Ending de schoonste keuze. De IDE onthoudt je keuze, dus vergeet die niet te controleren als je naar een ander project overstapt.
Data van de computer naar Arduino sturen: Serial.read(), parseInt(), readStringUntil()
De bytes die je vanuit de Serial Monitor verstuurt, komen in de ontvangstbuffer van het board te staan (64 bytes op de Uno). Serial.available() vertelt hoeveel bytes daarin wachten, Serial.read() pakt de volgende byte en haalt hem uit de buffer (en geeft -1 als er geen data is) en Serial.peek() kijkt naar de volgende byte zonder hem te verwijderen. Onthoud dat alles wat je via het toetsenbord typt als ASCII-tekens aankomt: typ je 7, dan ontvangt het board niet het getal 7 maar 55, de code van het teken '7'. Een voorbeeld van eenvoudige commando's met één toets vind je in het artikel Arduino-commando's; hier behandelen we getallen met meerdere cijfers en commando's uit woorden. Als de buffer vol raakt, gaan nieuw binnenkomende bytes verloren, dus timen met millis() in plaats van lang wachten met delay() in loop() maakt ook het seriële lezen betrouwbaarder.
Serial.parseInt() haalt het eerste gehele getal uit de binnenkomende tekens: het slaat voorafgaande letters en spaties over, voegt de cijfers samen en stopt bij het eerste teken dat geen cijfer is; ook een minteken begrijpt het. De tekst "128" wordt dus het getal 128. Voor kommagetallen doet Serial.parseFloat() hetzelfde. Deze functies hebben een gewoonte die je moet kennen: komt er geen getal binnen, dan wachten ze standaard 1000 ms en geven dan 0 terug. De klassieke bug gaat zo: met de instelling New Line stuur je 42, parseInt leest 42, maar de '\n' blijft in de buffer staan. In de volgende ronde ziet loop() dat available() groter is dan 0 en roept parseInt opnieuw aan, die een seconde wacht en 0 teruggeeft. Het resultaat is een 0 na elk getal en je snapt niet waarom de led een seconde na elk getal uitgaat. De code hieronder lost het probleem bij de wortel op door het volgende teken weg te gooien als het geen cijfer is, en verkort het wachten met 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}Voor commando's uit woorden is het het makkelijkst om de hele regel als String te lezen. Serial.readStringUntil('\n') leest tot er een '\n' binnenkomt, gooit het regeleindeteken weg en geeft de rest terug. Staat de instelling op Both NL & CR, dan blijft er een '\r' aan het eind van de tekst staan, wordt je commando "on" dus "on\r" en mislukt de vergelijking. Pas daarom meteen trim() toe op de regel: die verwijdert spaties vooraan en achteraan en ook de tekens '\r' en '\n'. toLowerCase() maakt ON, On en on gelijk. Het voorbeeld hieronder begrijpt de commando's on, off, blink 250 en status; gebruik de Serial Monitor op 115200 baud met New Line. Omdat het knippert met millis() in plaats van delay(), reageert het op elk moment direct op een nieuw commando.
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}| Functie | Geeft terug | Hoe lang wacht ze? | Het best te gebruiken voor |
|---|---|---|---|
| Serial.read() | Eén byte (int), -1 als er geen data is | Wacht niet | Commando's van één teken, je eigen parser |
| Serial.peek() | De volgende byte, zonder hem te verwijderen | Wacht niet | Kijken wat er aankomt voordat je beslist |
| Serial.parseInt() | Een long integer, 0 bij timeout | De setTimeout-tijd (standaard 1000 ms) | Getalinvoer: hoek, snelheid, helderheid |
| Serial.parseFloat() | Een float, 0 bij timeout | De setTimeout-tijd | Instellingen met decimalen, zoals 2.5 |
| Serial.readStringUntil(c) | De tekst tot teken c (String) | Tot c binnenkomt of de tijd om is | Commando's met woorden en parameters |
| Serial.readBytesUntil(c, buffer, n) | Aantal gelezen bytes; schrijft de tekst in een char-array | Tot c binnenkomt, n bytes zijn gelezen of de tijd om is | RAM-vriendelijk lezen zonder String |
Live grafieken tekenen met de Serial Plotter
De Serial Plotter verandert de getallen die van de seriële poort komen in een live lijngrafiek; open hem met het golfvormicoon rechtsboven in de IDE of via het menu Tools › Serial Plotter. Het formaat is heel eenvoudig: scheid de waarden op een regel met komma's, spaties of tabs en sluit de regel af met println. Elke regel wordt één tijdstap in de grafiek en elke waarde op de regel wordt een aparte gekleurde lijn. Zet je vóór de waarden een naam in de vorm label:waarde, dan krijgen de lijnen die naam en kun je ze met de selectievakjes boven de grafiek één voor één verbergen of tonen; zonder labels krijgen de lijnen namen als value 1 en value 2. Ook hier moet het snelheidsmenu overeenkomen met je code. De code hieronder tekent de ruwe meting op A0 en de uitgemiddelde versie ervan in dezelfde grafiek:
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}- Leg de schaal vast: De Serial Plotter past de verticale as steeds aan de binnenkomende waarden aan, waardoor kleine schommelingen enorm lijken. Voeg je aan elke regel twee constante waarden toe zoals Min:0,Max:1023,, dan blijft de as vast.
- Gebruik geen spaties in labels: Omdat spaties en komma's als scheidingstekens gelden, wordt "Room Temp:24" in twee delen gesplitst; gebruik namen met een underscore, zoals Room_Temp.
- Alleen labels en getallen op de regel: Eenheden en beschrijvingen zoals "Temp 24 C" verstoren de grafiek; druk beschrijvingen voor de Serial Monitor af in aparte code.
- Stem de verzendsnelheid af: delay(20) betekent ongeveer 50 regels per seconde. Stuur je te snel, dan scrolt de grafiek in een oogwenk weg; stuur je te langzaam, dan lijkt de lijn op een trap.
- Zie het filter met eigen ogen: Als je de ruwe waarde en het gemiddelde in dezelfde grafiek tekent, zie je meteen hoeveel een filter de ruis vermindert; methodes staan in het artikel sensordata filteren.
- Gebruik een ander tool voor logging: De Serial Plotter slaat geen data op in een bestand. Druk bij lange metingen de waarden af als CSV-regels en importeer ze in Excel of lees ze met Python.
Debugtechnieken met de Serial Monitor
De Arduino Uno heeft geen debugger waarmee je stap voor stap door je code loopt; de Serial Monitor doet die taak. Maar printregels die willekeurig door je code verspreid staan, worden al snel een onleesbare hoop tekst. Met deze gewoonten vind je bugs veel sneller:
- Druk eerst een bericht af vanuit setup(): Zie je de regel "Started" één keer bij elke start van het board, dan draait het. Blijft die regel zich herhalen, dan herstart het board steeds en ligt het probleem bij de voeding in plaats van bij de code; zie de gids Arduino blijft resetten.
- Druk waarden af met hun naam: Schrijf in plaats van alleen 512 liever temp=24.5 hum=40; dan hoef je later niet uit te zoeken welk getal bij wat hoort.
- Markeer waar je bent: Als het programma ergens vastloopt, zet dan korte markeringen zoals A, B, C voor de belangrijke stappen. De laatste markering op het scherm laat zien waar het programma bleef hangen.
- Druk af bij verandering, niet bij elke ronde: loop() draait duizenden keren per seconde. Bij elke ronde afdrukken overspoelt het scherm en vertraagt het programma; druk een waarde alleen af als hij verandert, of één keer per seconde met millis().
- Meet de tijd: Wil je zien hoe lang een bewerking duurt, bewaar dan de waarde van micros() ervoor en erna en druk het verschil af. Zo ontdek je een trage sensormeting of een lange lus.
- Druk niet af binnen interrupts: Seriële uitvoer kost tijd; Serial.print gebruiken in een interruptfunctie maakt die onnodig lang en kan ervoor zorgen dat je andere gebeurtenissen mist. Zet in de interrupt alleen een vlagvariabele en doe het afdrukken in loop(); details in het artikel Arduino-interrupts.
- Zet debugregels achter één schakelaar: Met de macro's hieronder haal je alle debuguitvoer volledig uit de code door DEBUG op 0 te zetten; in het afgewerkte project bespaar je zowel flashgeheugen als tijd.
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}Onthoud dat seriële uitvoer iets kost. Op de Uno is de zendbuffer ook 64 bytes; als die vol is, wacht Serial.print() tot er ruimte is en wordt loop() trager. Je kunt dit zelf meten met de lusteller in de code hierboven: voeg je een regel van 25 tekens toe die bij elke ronde wordt afgedrukt, dan zakt het programma bij 9600 baud naar ongeveer veertig rondes per seconde, terwijl afdrukken bij verandering er duizenden houdt. Wil je zeker weten wat het board net afdrukte voordat het vastliep of resette, roep dan na de kritieke regel Serial.flush() aan; die wacht tot alles in de buffer is verstuurd. In complexere programma's maakt overstappen op een toestandsmachine en slechts één regel afdrukken wanneer de toestand verandert het opsporen van bugs veel makkelijker.
Seriële uitvoer op de ESP32
Op ESP32 DevKit-boards is Serial UART0 op GPIO 1 (TX) en GPIO 3 (RX), via de CP2102- of CH340-chip op het board met USB verbonden. De gebruikelijke snelheid is 115200 baud, omdat de ROM in de chip tijdens het opstarten bij deze snelheid ook regels afdrukt zoals rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT); houd je de monitor op 115200, dan worden die regels ook leesbaar. De ESP32 Arduino-core biedt Serial.printf() en ondersteunt het afdrukken van floats met %f. De extra seriële poorten Serial1 en Serial2 kun je aan willekeurige pins toewijzen; bij het aansluiten van een module is Serial2 op GPIO 16 en 17 gangbaar. Blijft de Serial Monitor leeg op boards met ingebouwde USB, zoals de ESP32-S3 en ESP32-C3, zet dan Tools › USB CDC On Boot op Enabled. Om de eigen waarschuwingen van de core te zien, kies je Error, Warn, Info, Debug of Verbose in het menu Tools › Core Debug Level, en in je eigen code kun je logregels met bestands- en regelinformatie afdrukken met de macro's log_e, log_w en log_i.
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}Bij problemen met de wifiverbinding, onverwachte resets en Guru Meditation-fouten is de Serial Monitor de eerste plek om te kijken: het type fout, de resetreden en de backtrace-regels verschijnen hier. Hoe je deze meldingen duidt, leggen we uit in de gidsen ESP32 brownout en Guru Meditation en ESP32 maakt geen verbinding met wifi. Gebruik je de ESP32 voor het eerst, begin dan met het artikel Wat is de ESP32?.
Seriële uitvoer op de Raspberry Pi Pico: Arduino en MicroPython
De Raspberry Pi Pico heeft geen USB-naar-serieel-brugchip; de RP2040 regelt USB zelf en verschijnt rechtstreeks als seriële poort (USB CDC) bij de computer. In de Arduino-Pico-core van Earle Philhower is Serial deze USB-poort, en omdat de data met USB-snelheid stroomt, wordt de snelheidswaarde in Serial.begin() genegeerd. Dat heeft twee gevolgen: het maakt niet meer uit welke snelheid je in de monitor kiest, maar het board reset niet zoals een Uno wanneer je de Serial Monitor opent. De eerste berichten die je in setup() afdrukt, zijn al verstuurd en verloren op het moment dat je de monitor opent, dus wacht even tot de computer de poort heeft geopend, zoals hieronder getoond. Hetzelfde geldt voor ATmega32U4-boards zoals de Leonardo, Micro en Pro Micro. De echte UART van de Pico op de pins GP0 en GP1 gebruik je onder de naam 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 is het nog eenvoudiger: alles wat je met print() afdrukt gaat via USB naar de computer en verschijnt in de Shell van Thonny; je hoeft geen baudrate in te stellen. Open je in Thonny het menu View › Plotter, dan worden de getallen in de regels een live grafiek, net als in de Serial Plotter. Om data van de computer te ontvangen kun je input() gebruiken, maar input() stopt het programma tot er een regel binnenkomt. Wil je naar commando's luisteren terwijl je blijft meten, controleer dan met select.poll() of er data op stdin wacht, zoals hieronder getoond; typ gewoon on of off in de Shell en druk op Enter. De Pico en de installatie van MicroPython behandelden we in het artikel Wat is de 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)Serial Monitor leeg of poort bezet: veelvoorkomende fouten en oplossingen
| Symptoom | Oorzaak | Oplossing |
|---|---|---|
| Het scherm is helemaal leeg | Geen Serial.begin() of de verkeerde poort gekozen | Voeg Serial.begin() toe aan setup(), kies de juiste poort in de boardselector |
| Not connected. Select a board and a port to connect automatically. | Geen poort gekozen in de IDE of het board is losgekoppeld | Sluit het board aan en selecteer het in het menu Tools › Port |
| Seriële poort bezet of Access is denied | De poort is open in een ander IDE-venster, in PuTTY of in een Python-script | Sluit het programma dat de poort vasthoudt; een poort kan maar door één programma tegelijk worden geopend |
| Eerste regels ontbreken op een Leonardo of Pico | Een board met ingebouwde USB reset niet wanneer de monitor opent | Wacht kort in setup() met while (!Serial) |
| Er verschijnt niets op een ESP32-S3/C3 | USB CDC On Boot staat uit, de uitvoer gaat naar de UART-pins | Tools › USB CDC On Boot: Enabled |
| Na elk getal verschijnt een 0 | parseInt loopt op het regeleindeteken in een timeout | Sla tekens die geen cijfer zijn over of kies No Line Ending |
| Commandovergelijkingen kloppen nooit | Er blijft een '\r' aan het eind van de tekst staan | Pas trim() toe na het lezen |
| De poort verschijnt nooit in de lijst | Een kabel die alleen oplaadt of een ontbrekend CH340/CP210x-stuurprogramma | Gebruik een datakabel, installeer het stuurprogramma |
Projectideeën met seriële communicatie
- Led en relais aansturen vanaf de computer: Breid de commandoparser uit dit artikel uit om met de commando's on, off en blink een relais of motor aan te sturen.
- Sensordatalogger: Druk temperatuur en luchtvochtigheid af als CSV-regels met komma's en maak er op de computer een tabel en grafiek van; de DHT11 is een goede sensor om mee te beginnen.
- Live lichtgrafiek: Bekijk de waarde van een LDR of potentiometer in de Serial Plotter en zie het effect van het filter in dezelfde grafiek.
- Desktoppaneel met Python: Lees de data die de Arduino verstuurt met een Python-programma en bouw een interface met knoppen; details in het artikel Arduino Python seriële communicatie.
- Teststation voor modules: Ook gps-, Bluetooth- en GSM-modules gebruiken een seriële poort; stuur de ruwe data van de module door naar de Serial Monitor om te zien of hij werkt (HC-05, NEO-6M gps).
- Uitproberen zonder board: Heb je geen board bij de hand, dan heeft Tinkercad ook een Serial Monitor; je kunt de code uit dit artikel draaien in een Tinkercad-simulatie.
Als je eenmaal vertrouwd bent met de Serial Monitor, is bugs zoeken in Arduino geen gokwerk meer maar een kwestie van meten. Lees als volgende stap het artikel UART seriële communicatie om twee boards via TX en RX met elkaar te laten praten en het artikel USB-naar-TTL-converter om boards zonder USB te programmeren. In de BlueGrays-app vind je projecten zoals de afstand van een HC-SR04 afdrukken in de Serial Monitor, lichtsterkte lezen met een LDR, temperatuur en luchtvochtigheid meten met een DHT11 en twee Arduino's koppelen via een seriële lijn, stap voor stap met schakelschema's en kant-en-klare code.
Veelgestelde vragen
Hoe open ik de Arduino Serial Monitor?
Klik na het uploaden van je code op het vergrootglas rechtsboven in de Arduino IDE, gebruik het menu Tools › Serial Monitor of druk op Ctrl+Shift+M. In IDE 2 opent de monitor in het onderste paneel. In de boardselector moet de juiste poort zijn geselecteerd en het snelheidsmenu rechts moet overeenkomen met de Serial.begin()-waarde in je code.
Waarom toont de Serial Monitor onleesbare tekens?
De meest voorkomende oorzaak is dat de baudrate in de Serial Monitor verschilt van de Serial.begin()-waarde in je code; zodra die twee overeenkomen, wordt de tekst leesbaar. Is alleen één regel bij het opstarten onleesbaar, dan is dat de eigen bootmelding van de ESP8266 of ESP32 en dat is normaal. Een verkeerde klokfrequentie kiezen op boards zoals de Pro Mini of een module op de pins D0/D1 aansluiten geeft hetzelfde symptoom.
Moet ik 9600 of 115200 baud gebruiken voor Arduino?
Beide werken; belangrijk is dat je code en de Serial Monitor dezelfde snelheid gebruiken. 9600 baud verwerkt ongeveer 960 tekens per seconde en is genoeg voor eenvoudige Uno-projecten. Druk je veel data af of gebruik je een ESP32 of Pico, kies dan 115200; dat is 12 keer sneller en afdrukken vertraagt je programma minder.
Wat is het verschil tussen Serial.print en Serial.println?
Serial.print() schrijft de waarde en laat de cursor op dezelfde regel staan; Serial.println() voegt na het schrijven de tekens carriage return en newline (\r\n) toe. Om meerdere waarden op één regel te tonen gebruik je eerst print en aan het eind println. De regel moet ook met println eindigen, zodat de Serial Plotter elke regel als aparte meting kan tellen.
Waarom verschijnt er niets in de Serial Monitor?
Controleer eerst of setup() Serial.begin() bevat en of de juiste poort is geselecteerd in de boardselector. Op boards met ingebouwde USB, zoals de Leonardo, Pico en ESP32-S3, kunnen de eerste berichten in setup() worden verstuurd en verloren gaan voordat de monitor opent; voeg een korte wachttijd toe met while (!Serial). Op de ESP32-S3 en C3 moet bovendien de instelling USB CDC On Boot in het menu Tools op Enabled staan.
Waarom reset mijn Arduino als ik de Serial Monitor open?
Op de Uno, Nano en Mega is de DTR-lijn van de USB-chip via een condensator met de RESET-pin verbonden; wanneer de poort opent, geeft deze lijn een korte puls en herstart het board. Deze opzet is er om uploaden makkelijker te maken en zorgt ervoor dat je de berichten uit setup() niet mist. Wil je dat niet, dan kun je een condensator van 10 µF tussen RESET en GND plaatsen, maar die moet je vóór het uploaden verwijderen.
Projecten om hierna te bouwen
Alle projecten bekijken
Afstand meten met HC-SR04 (Serial-weergave)
De HC-SR04-sensor werkt net als een vleermuis die in het donker zijn weg vindt: hij stuurt een geluid uit dat je niet kunt horen, luistert naar de echo en meet hoe ver het object voor hem staat.

Lichtsterkte meten met een LDR
Wil je zien hoe licht je kamer is, als getal? De LDR, een klein onderdeel dat op licht reageert, meet het licht om je heen en de Arduino schrijft de waarde elke halve seconde naar je computerscherm.

Temperatuur en luchtvochtigheid met DHT11
Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

Lichtsterkte meten met de ESP32 en een LDR-module
Volg in de Serial Monitor in realtime de ruwe ADC-waarde van de LDR-module en het relatieve lichtpercentage, berekend uit referentiewaarden voor donker en licht. Dit percentage is geen luxmeting. Je leert hoe de module gekalibreerd wordt. Ideaal om vóór Project 10 te doen, want je gebruikt het om de drempelwaarde te bepalen.

Codes van een IR-afstandsbediening uitlezen
Elke toets van je tv-afstandsbediening stuurt met onzichtbaar licht een geheime code.

RFID-waarde uitlezen
Je sleutelhanger of toegangskaart verbergt een geheim ID-nummer en dit project leest het uit. Houd de kaart bij de RFID-lezer en de Arduino schrijft het kaartnummer naar je computerscherm.

Eenrichtingscommunicatie tussen 2 Arduino's
Je laat twee Arduino's met elkaar praten via één draad: druk op de knop van de ene en de led van de andere gaat aan, druk nog een keer en hij gaat uit.

Tweerichtingscommunicatie tussen 2 Arduino's
Twee Arduino's zijn met draden aan elkaar gekoppeld en praten met elkaar: druk op de knop van de ene en het lampje van de andere gaat aan, druk nog eens en het gaat uit.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

