Seriële communicatie tussen Arduino en Python: pyserial, CSV en live grafieken
Seriële communicatie tussen Arduino en Python met pyserial: installeer het, vind de poort, log sensordata naar CSV, stuur commando's en teken live grafieken met matplotlib.
Seriële communicatie tussen Arduino en Python betekent dat een Python-programma op je computer via de USB-kabel gegevens uitwisselt met een Arduino. De Arduino meet een sensor en schrijft het resultaat naar de seriële poort; Python leest die regels met de bibliotheek pyserial, slaat ze op in een CSV-bestand, tekent er een grafiek van, of neemt een beslissing en stuurt een commando terug naar de Arduino. Zo combineer je de nauwkeurige hardwarebesturing van de Arduino met de kracht van Python voor gegevensverwerking, grafieken, AI en automatisering. Je hebt er ook geen extra module voor nodig: de USB-kabel waarmee je sketches uploadt is genoeg.
In deze gids leer je stap voor stap hoe je pyserial installeert, de poort van de Arduino automatisch vindt, sensordata met tijdstempels naar een CSV-bestand logt, led- en PWM-commando's vanuit Python naar de Arduino stuurt en een live grafiek tekent met matplotlib. Daarna bespreken we de keuze van een gegevensformaat en regeleinde, de twee meest verwarrende problemen (de fout 'poort bezet' en het board dat reset wanneer de poort wordt geopend) en hoe dezelfde taak in MicroPython op een Raspberry Pi Pico verschilt. De voorbeelden zijn geschreven voor de Arduino Uno; de aanpassingen voor de ESP32 en de Pico zie je apart.

Hoe praat Arduino met Python?
De USB-naar-seriële chip op de Arduino Uno (een ATmega16U2 op originele boards, meestal een CH340 op klonen) verschijnt op je computer als een virtuele seriële poort: COM3, COM4 enzovoort in Windows; /dev/cu.usbmodem… of /dev/cu.usbserial-… op macOS; /dev/ttyACM0 of /dev/ttyUSB0 op Linux. Elk teken dat de Arduino met Serial.print() schrijft, stroomt als bytes via deze poort naar de computer; aan de Python-kant opent pyserial de poort als een bestand, leest ervan en schrijft ernaartoe. Een belangrijk onderscheid: de Arduino Uno voert geen Python-code uit. Het board draait Arduino-code in C++, de computer draait Python, en de twee praten alleen via de seriële lijn. Om dezelfde taal te spreken moeten deze instellingen overeenkomen:
| Instelling | Arduino-kant | Python-kant | Let op |
|---|---|---|---|
| Port | Wordt automatisch aangemaakt via USB | serial.Serial("COM3", ...) | De poortnaam hangt af van het besturingssysteem |
| Snelheid (baud) | Serial.begin(115200) | serial.Serial(port, 115200) | Als ze verschillen, krijg je onzintekens |
| Frame | 8 databits, geen pariteit, 1 stopbit (8N1) | De standaardwaarde van pyserial is ook 8N1 | Je hoeft dit zelden te wijzigen |
| Regeleinde | Serial.println() voegt \r\n toe | readline() leest tot het \n tegenkomt | Vergeet de \n niet toe te voegen als je vanuit Python verstuurt |
| Timeout | Serial.setTimeout(), standaard 1000 ms | timeout=1 (seconden) | Met timeout=None wacht readline() eindeloos |
pyserial installeren (Windows, macOS, Linux)
- Zorg dat Python 3 is geïnstalleerd. Vink in Windows op het eerste scherm van het installatieprogramma van de officiële Python-website het vakje Add python.exe to PATH aan; op macOS en Linux is Python 3 meestal al voorgeïnstalleerd.
- Open een terminal (Opdrachtprompt of PowerShell in Windows) en typ python -m pip install pyserial. Herkent Windows het commando python niet, probeer dan py -m pip install pyserial; op macOS en Linux kan het commando python3 -m pip install pyserial zijn.
- Controleer de installatie: python -c "import serial; print(serial.__version__)" moet een versienummer als 3.5 tonen.
- Voor het gedeelte over de live grafiek heb je ook matplotlib nodig: python -m pip install matplotlib.
- Voeg op Linux je gebruiker toe aan de groep dialout, zodat je de poort kunt openen: sudo usermod -a -G dialout $USER, en log daarna uit en weer in. Geeft pip op Raspberry Pi OS of recente Ubuntu-versies de fout externally-managed-environment, gebruik dan sudo apt install python3-serial of maak een virtuele omgeving met python3 -m venv en voer pip daarin uit.
Op welke poort zit de Arduino? De poort vinden met Python
Het eenvoudigst is het menu Tools > Port in de Arduino IDE te bekijken, maar Python kan de poorten ook zelf weergeven. Typ python -m serial.tools.list_ports -v in een terminal en je ziet de naam, beschrijving en hardware-ID (VID:PID) van elke poort. Weet je niet welke regel de Arduino is, haal dan het board los, voer het commando opnieuw uit en noteer de poort die verdwenen is. Op macOS verschijnt hetzelfde board zowel als /dev/tty… als /dev/cu…; gebruik in Python degene die met cu begint.

| USB-chip | Waar je hem vindt | VID:PID | Naam in Windows | Poortnaam in Linux |
|---|---|---|---|---|
| ATmega16U2 | Originele Uno R3, Mega 2560 | 2341:0043 (Uno) | Arduino Uno (COMx) | /dev/ttyACM0 |
| CH340 | Kloon-Uno-, Nano- en Mega-boards | 1A86:7523 | USB-SERIAL CH340 (COMx) | /dev/ttyUSB0 |
| CP2102 | ESP32 DevKit, NodeMCU | 10C4:EA60 | Silicon Labs CP210x USB to UART Bridge (COMx) | /dev/ttyUSB0 |
| FT232R | Oudere Nano's, FTDI-kabels | 0403:6001 | USB Serial Port (COMx) | /dev/ttyUSB0 |
| RP2040 (ingebouwde USB) | Raspberry Pi Pico met MicroPython | 2E8A:0005 | USB Serial Device (COMx) | /dev/ttyACM0 |
De onderstaande functie toont alle poorten en geeft, als ze een board herkent aan de VID, de poortnaam van dat board terug. Sla de code op als port_bul.py en je kunt in je andere scripts from port_bul import port_bul en PORT = port_bul() schrijven in plaats van elke keer de poortnaam met de hand aan te passen.
1import serial.tools.list_ports
2
3# Bilinen USB yongalarının üretici kimlikleri (VID) / Vendor IDs of common USB chips
4BILINEN = {
5 0x2341: "Arduino (orijinal / genuine)",
6 0x2A03: "Arduino (orijinal / genuine)",
7 0x1A86: "CH340 (klon / clone)",
8 0x10C4: "CP210x (ESP32, NodeMCU)",
9 0x0403: "FTDI",
10 0x2E8A: "Raspberry Pi Pico",
11}
12
13
14def port_bul():
15 portlar = sorted(serial.tools.list_ports.comports())
16 for p in portlar:
17 print(p.device, "|", p.description, "|", p.hwid) # tüm portları listele / list every port
18 for p in portlar:
19 if p.vid in BILINEN:
20 print("Bulundu / found:", p.device, "->", BILINEN[p.vid])
21 return p.device
22 return None
23
24
25if __name__ == "__main__":
26 if port_bul() is None:
27 print("Kart yok: kabloyu ve surucuyu kontrol et / no board: check cable and driver")Gegevens versturen vanaf de Arduino: de eerste sketch
De voorbeelden gebruiken een potentiometer aangesloten op pin A0: de middelste pin gaat naar A0, een buitenste pin naar 5V en de andere naar GND. In plaats van een potentiometer kun je ook een LDR met een weerstand van 10 kΩ aansluiten als spanningsdeler. De sketch leest elke 200 ms een waarde en stuurt het resultaat als één regel in het formaat time,value:
1// A0 değerini "millis,deger" CSV satırı olarak gönderir / Sends the A0 reading as a "millis,value" CSV line
2const int SENSOR_PIN = A0; // potansiyometrenin orta ucu / potentiometer wiper
3const unsigned long ARALIK = 200; // gönderim aralığı, ms / send interval, ms
4unsigned long sonGonderim = 0;
5
6void setup() {
7 Serial.begin(115200); // Python'daki hızla aynı olmalı / must match the baud rate in Python
8}
9
10void loop() {
11 if (millis() - sonGonderim >= ARALIK) { // delay() olmadan zamanlama / timing without delay()
12 sonGonderim = millis();
13 int deger = analogRead(SENSOR_PIN); // 0-1023
14 Serial.print(sonGonderim); // zaman damgası / timestamp
15 Serial.print(','); // ayırıcı / separator
16 Serial.println(deger); // sonuna \r\n ekler / appends \r\n
17 }
18}Door millis() in plaats van delay() te gebruiken, kun je later makkelijker commando's vanuit Python in dezelfde lus verwerken; zie millis versus delay voor details. Open na het uploaden de Serial Monitor op 115200 baud en je ziet regels als 2573,512 voorbijkomen. Dit is alleen een controle: sluit de Serial Monitor altijd voordat je het Python-script uitvoert, anders is de poort bezet. Ben je nieuw met de Serial Monitor, dan helpt de gids over de Arduino Serial Monitor.
Arduino-data lezen met Python en opslaan in CSV
1import csv
2import time
3from datetime import datetime
4
5import serial
6
7PORT = "COM3" # macOS: /dev/cu.usbmodem14101, Linux: /dev/ttyACM0
8BAUD = 115200 # Arduino'daki Serial.begin ile aynı / same as Serial.begin on the Arduino
9
10with serial.Serial(PORT, BAUD, timeout=1) as ser, \
11 open("olcumler.csv", "w", newline="", encoding="utf-8") as dosya:
12 time.sleep(2) # Uno port açılınca resetlenir / the Uno resets when the port opens
13 ser.reset_input_buffer() # yarım kalmış eski veriyi at / drop stale, partial data
14 yazici = csv.writer(dosya)
15 yazici.writerow(["tarih", "zaman_ms", "deger", "volt"]) # başlık satırı / header row
16 print("Kayit basladi, durdurmak icin Ctrl+C / logging, press Ctrl+C to stop")
17 try:
18 while True:
19 satir = ser.readline().decode("utf-8", errors="ignore").strip()
20 parcalar = satir.split(",")
21 if len(parcalar) != 2:
22 continue # boş ya da beklenmeyen satır / empty or unexpected line
23 try:
24 zaman_ms, deger = int(parcalar[0]), int(parcalar[1])
25 except ValueError:
26 continue # bozuk satır / corrupted line
27 volt = deger * 5.0 / 1023 # Uno ADC: 0-1023 -> 0-5 V
28 yazici.writerow([datetime.now().isoformat(timespec="seconds"),
29 zaman_ms, deger, round(volt, 3)])
30 dosya.flush() # satırı hemen diske yaz / write the row to disk now
31 print(zaman_ms, deger, f"{volt:.2f} V")
32 except KeyboardInterrupt:
33 print("Durduruldu / stopped")Dit script opent de poort met timeout=1: readline() wacht maximaal 1 seconde op een regeleinde, geeft een leeg bytes-object terug als er niets binnenkomt en de lus blijft dus nooit hangen. De binnenkomende data is van het type bytes; decode() zet het om in tekst, strip() verwijdert de afsluitende \r\n en split(",") splitst de regel in kolommen. De time.sleep(2) en reset_input_buffer() na het openen van de poort gooien de halve regels weg die binnenkomen terwijl de Uno herstart; hieronder zie je waarom. Het bestand openen met newline="" voorkomt lege rijen in Windows, en flush() houdt de tot nu toe opgeslagen metingen op schijf, zelfs als het programma plotseling stopt. Druk in de terminal op Ctrl+C om het loggen te stoppen.
Commando's van Python naar de Arduino sturen
De communicatie werkt in beide richtingen. De onderstaande Arduino-sketch wacht op commando's die regel voor regel binnenkomen: LED ON en LED OFF schakelen de ingebouwde led, PWM 128 stelt de helderheid in van een led op pin 9 en READ stuurt de waarde op A0 terug. Elk commando krijgt een kort antwoord, zodat Python weet dat het commando echt is verwerkt. De juiste weerstand voor de led op pin 9 vind je met de ledweerstandcalculator; Wat is PWM? legt uit hoe PWM werkt.
1// Python'dan gelen satır komutlarını işler / Handles line-based commands from Python
2const int LED_PIN = LED_BUILTIN; // Uno'da pin 13 / pin 13 on the Uno
3const int PWM_PIN = 9; // 220 ohm dirençli LED / LED with a 220 ohm resistor
4
5void setup() {
6 pinMode(LED_PIN, OUTPUT);
7 pinMode(PWM_PIN, OUTPUT);
8 Serial.begin(115200);
9 Serial.setTimeout(50); // readStringUntil en fazla 50 ms bekler / waits at most 50 ms
10 Serial.println("HAZIR"); // Python bu satırı bekler / Python waits for this line
11}
12
13void loop() {
14 if (Serial.available() > 0) {
15 String komut = Serial.readStringUntil('\n'); // satır sonuna kadar oku / read up to the newline
16 komut.trim(); // \r ve boşlukları sil / strip \r and spaces
17
18 if (komut == "LED ON") {
19 digitalWrite(LED_PIN, HIGH);
20 Serial.println("OK LED ON");
21 } else if (komut == "LED OFF") {
22 digitalWrite(LED_PIN, LOW);
23 Serial.println("OK LED OFF");
24 } else if (komut.startsWith("PWM ")) {
25 int deger = komut.substring(4).toInt(); // "PWM 128" -> 128
26 deger = constrain(deger, 0, 255); // 0-255 aralığında tut / keep it within 0-255
27 analogWrite(PWM_PIN, deger);
28 Serial.print("OK PWM ");
29 Serial.println(deger);
30 } else if (komut == "READ") {
31 Serial.println(analogRead(A0)); // A0 ölçümünü gönder / send the A0 reading
32 } else if (komut.length() > 0) {
33 Serial.print("ERR "); // bilinmeyen komut / unknown command
34 Serial.println(komut);
35 }
36 }
37}1import time
2
3import serial
4
5
6def komut_gonder(ser, komut):
7 ser.write((komut + "\n").encode("ascii")) # satır sonu şart / the newline is required
8 return ser.readline().decode("ascii", errors="ignore").strip() # cevabı bekle / wait for the reply
9
10
11with serial.Serial("COM3", 115200, timeout=2) as ser:
12 bitis = time.time() + 3 # en fazla 3 sn bekle / wait at most 3 s
13 while time.time() < bitis:
14 if ser.readline().strip() == b"HAZIR": # Arduino açıldı / the Arduino is up
15 break
16 print(komut_gonder(ser, "LED ON")) # OK LED ON
17 time.sleep(1)
18 print(komut_gonder(ser, "PWM 128")) # OK PWM 128
19 print("A0 =", komut_gonder(ser, "READ")) # A0 = 512
20 print(komut_gonder(ser, "LED OFF")) # OK LED OFFDe meest gemaakte fout aan de Python-kant is de \n aan het eind van een commando vergeten: als readStringUntil('\n') het regeleinde niet vindt, wacht de Arduino de tijd af die met Serial.setTimeout() is ingesteld en verwerkt het commando pas daarna. In deze sketch is die tijd 50 ms; met de standaard 1000 ms zou elk commando een seconde vertraagd zijn. write() accepteert alleen bytes, dus je moet de tekst omzetten met encode() of er een b voor zetten (b"LED ON\n"). Het script wacht eerst maximaal 3 seconden op de regel HAZIR (klaar): omdat de Uno herstart wanneer de poort opent, belandt een direct verzonden commando in de bootloader en gaat het verloren. Na elk commando het antwoord lezen, een patroon van verzoek en antwoord, houdt beide kanten gelijk en voorkomt dat de buffers vollopen; de ontvangstbuffer van de Uno is slechts 64 bytes.
Gegevensformaat en regeleinden: wat kies je?
De seriële lijn geeft je alleen een stroom bytes; het is aan jou om aan te geven waar de ene meting eindigt en de volgende begint. De robuustste manier is elke meting op een eigen regel te schrijven en elke regel af te sluiten met \n. Welk formaat je binnen de regel gebruikt, hangt af van de omvang van je project:
| Formaat | Voorbeeldregel | Voordelen | Nadelen |
|---|---|---|---|
| Eén waarde | 512 | Eenvoudigste formaat; de Serial Plotter van Arduino tekent het direct | Bij meerdere waarden is onduidelijk welke welke is |
| CSV | 2573,512,23.5 | Kort; Excel en pandas lezen het direct | De kolomvolgorde moet aan beide kanten gelijk blijven |
| Sleutel:waarde | temp:23.5,hum:41 | Leesbaar; de Serial Plotter toont de labels | Langer en iets meer werk om te verwerken |
| JSON | {"t":23.5,"h":41} | In Python in één regel te decoderen met json.loads() | Langste formaat; belast het beperkte RAM van de Uno |
| Binair | 2 bytes: 0x02 0x00 | Snelste en kortste optie | Niet leesbaar voor mensen; vereist de module struct en een startbyte |
Regeleinden zijn een andere veelvoorkomende bron van verwarring. Serial.println() voegt twee tekens toe aan het eind van elke regel: carriage return (\r, CR) en line feed (\n, LF). De readline() van Python wacht alleen op \n, dus een \r blijft aan het eind van de regel staan; strip() verwijdert beide. De lijst met regeleinden in de Serial Monitor van de Arduino IDE biedt No Line Ending, New Line, Carriage Return en Both NL & CR; als je de Arduino-sketch in de Serial Monitor test voordat je Python gebruikt, kies dan New Line, zodat hetzelfde teken wordt verstuurd als vanuit Python. Geef bij decimale getallen het aantal cijfers op, zoals in Serial.print(temperature, 1); op de Uno ondersteunt sprintf het floating-point-formaat (%f) niet, dus als je decimalen met sprintf probeert af te drukken, krijg je een vraagteken in plaats van het getal.
| Baudrate | Bytes per seconde (8N1) | Regels van 12 bytes per seconde | Wanneer gebruiken |
|---|---|---|---|
| 9600 | 960 | 80 | Trage sensoren, lange kabels, oudere voorbeeldsketches |
| 57600 | 5.760 | 480 | Metingen met gemiddelde snelheid |
| 115200 | 11.520 | 960 | Live grafieken, de ESP32 en de meeste nieuwe projecten |
Op de seriële lijn reist elke byte als 10 bits, inclusief start- en stopbit, dus 115200 baud betekent ongeveer 11.520 bytes per seconde. Voor een regel van 12 bytes, bestaand uit 25730,1023 plus het regeleinde (\r\n), is er ruimte voor maximaal 960 regels per seconde. Als de snelheid aan beide kanten verschilt, stromen er onzintekens over de lijn en geeft Python een UnicodeDecodeError. Tussen 5 en 20 metingen per seconde is ruim voldoende voor het menselijk oog en voor de meeste sensoren; veel vaker sturen dan nodig vertraagt de grafiek en maakt het bestand onnodig groot.
Een live grafiek tekenen met matplotlib
1from collections import deque
2
3import matplotlib.pyplot as plt
4import serial
5from matplotlib.animation import FuncAnimation
6
7ser = serial.Serial("COM3", 115200, timeout=0.1)
8N = 200 # ekrandaki ölçüm sayısı / readings on screen
9veri = deque([0] * N, maxlen=N) # eskiler kendiliğinden düşer / old values drop out
10
11fig, ax = plt.subplots()
12cizgi, = ax.plot(range(N), list(veri))
13ax.set_ylim(0, 1023) # Uno ADC aralığı / Uno ADC range
14ax.set_xlabel("Ornek / sample")
15ax.set_ylabel("A0")
16
17
18def guncelle(_):
19 while ser.in_waiting: # biriken bütün satırları oku / read every queued line
20 parca = ser.readline().decode("utf-8", errors="ignore").strip().split(",")
21 if len(parca) == 2 and parca[1].isdigit():
22 veri.append(int(parca[1]))
23 cizgi.set_ydata(list(veri))
24 return (cizgi,)
25
26
27ani = FuncAnimation(fig, guncelle, interval=50, blit=True, cache_frame_data=False) # ani silinmemeli / keep ani
28plt.show()
29ser.close()De grafiek is gebouwd op een deque die de laatste 200 metingen bewaart: elke nieuwe waarde komt rechts erbij en de oudste valt links automatisch weg. FuncAnimation roept de functie guncelle (bijwerken) elke 50 ms aan. De lus while ser.in_waiting binnen de functie is belangrijk: de Arduino stuurt nu 5 regels per seconde, maar zodra je de snelheid verhoogt, loopt de grafiek achter op de werkelijkheid als je per frame maar één regel leest; deze lus leest elke regel in de wachtrij en houdt de grafiek actueel. Verwijder de variabele ani niet: als geen enkele variabele naar het animatieobject verwijst, ruimt Python het op en bevriest het venster. Gebruik set_ylim(0, 4095) voor de ESP32 en set_ylim(0, 65535) voor de Pico. Wil je alleen even snel kijken, dan doet de Serial Plotter in de Arduino IDE het werk; het voordeel van Python is dat je de grafiek kunt opslaan, meerdere bronnen kunt combineren en de data tegelijk kunt verwerken.
De fout "poort bezet" en het auto-resetprobleem
Een seriële poort kan maar door één programma tegelijk worden geopend. Als de Serial Monitor of Serial Plotter van de Arduino IDE openstaat terwijl je Python-script draait, een ander Python-script de poort vasthoudt of software die poorten scant, zoals 3D-printerprogramma's, op de achtergrond draait, krijg je in Windows could not open port 'COM3': PermissionError(13, 'Access is denied.', None, 5) en op macOS en Linux Resource busy of Device or resource busy. Het werkt ook andersom: zolang een Python-script de poort open houdt, kan de Arduino IDE geen code uploaden. Gebruik daarom in je scripts de constructie with serial.Serial(...) as ser:; de poort sluit dan automatisch als het blok eindigt of er een fout optreedt. Maak er een gewoonte van het script met Ctrl+C te stoppen voordat je uploadt.
Het tweede probleem is sluwer: op de Arduino Uno, Nano en Mega is de DTR-lijn van de USB-chip via een condensator van 100 nF verbonden met de RESET-pin van de processor. Deze schakeling bestaat zodat de IDE het board bij het uploaden automatisch kan herstarten, maar elke keer dat pyserial de poort opent, verandert ook DTR en reset het board. Het board wacht eerst een of twee seconden in de bootloader en voert dan je sketch vanaf het begin uit. Commando's die je in die tijd verstuurt gaan verloren, en misschien mis je de eerste regels die de Arduino in setup() afdrukt. De oplossing is te wachten met time.sleep(2) na het openen van de poort of, robuuster, te wachten tot de Arduino een regel als HAZIR stuurt; het commandovoorbeeld hierboven doet precies dat. Open de poort één keer aan het begin van het programma en houd hem open tot het einde: een lus die de poort voor elke meting opent en sluit, reset het board steeds opnieuw.
Wil je de reset helemaal voorkomen, dan zijn er twee manieren. In software: maak de poort gesloten aan met ser = serial.Serial(), stel ser.port en ser.baudrate in, schrijf ser.dtr = False en roep dan ser.open() aan. Dit werkt meestal in Windows; op Linux en macOS kan het besturingssysteem DTR bij het openen van de poort nog steeds schakelen. In hardware: plaats een condensator van 10 µF tussen de pinnen RESET en GND van de Uno, met het positieve pootje op RESET. Boards met ingebouwde USB, zoals de Leonardo, Micro en Raspberry Pi Pico, herstarten niet als de poort opent; op deze boards kunnen regels die je code afdrukt voordat Python verbinding maakt verloren gaan, dus het is veiliger belangrijke berichten te sturen wanneer er een commando binnenkomt.
Seriële communicatie met Python via de ESP32
Alle Python-code hier werkt ook met de ESP32; je hoeft maar een paar dingen aan de Arduino-kant te wijzigen. Gebruik voor de analoge ingang een van de ADC1-pins (bijvoorbeeld GPIO 34). De ADC van de ESP32 is 12 bits en zet 0–3,3 V om naar 0–4095, dus bereken de spanning in Python met deger * 3.3 / 4095. Bij het opstarten drukt de ESP32 op 115200 baud zijn eigen opstartberichten af, zoals rst:0x1 (POWERON_RESET),boot:0x13; de bovenstaande scripts slaan regels over die niet naar getallen kunnen worden omgezet, dus deze berichten veroorzaken geen problemen. Afhankelijk van de auto-resetschakeling van het board en het besturingssysteem kan de ESP32 ook herstarten als de poort opent, dus de wachttijd en de HAZIR-regel helpen hier ook. De USB-chip is meestal een CP2102 of een CH340. Wil je de kabel liever vermijden, dan kan de ESP32 dezelfde data via Wi-Fi versturen; zie de gidsen ESP32 WebSocket en ESP32 Google Sheets. Is het je eerste ESP32, lees dan eerst Wat is de ESP32?
Raspberry Pi Pico en MicroPython: wat is het verschil?

Een andere manier om Python en hardware samen te brengen is Python rechtstreeks op het board te draaien. De Raspberry Pi Pico kun je programmeren in MicroPython: sensoren uitlezen, leds aansturen en timing gebeuren allemaal binnen de Pico met Python-syntaxis. MicroPython is echter een afgeslankte versie van Python voor de computer; matplotlib, pandas en OpenCV draaien niet op de Pico. Wil je dus data loggen, grafieken tekenen of met AI verwerken, dan verbind je de Pico ook met Python op je computer. De pyserial-code in dit artikel werkt ook met de Pico; je hoeft alleen de poortnaam, het waardebereik en de manier waarop commando-antwoorden worden gelezen aan te passen, zoals hieronder wordt uitgelegd.
| Kenmerk | Arduino + Python op de pc | Pico + MicroPython (standalone) | Pico + Python op de pc |
|---|---|---|---|
| Waar draait Python? | Alleen op de computer; het board draait C++ | In de Pico | Aan beide kanten: MicroPython op de Pico, Python op de computer |
| Is een computer nodig? | Ja, de data wordt op de computer verwerkt | Nee, hij werkt op USB-voeding of een batterij | Ja |
| Beschikbare bibliotheken | pyserial, matplotlib, pandas, numpy, OpenCV | Beperkte modules zoals machine en time | Elke bibliotheek op de computer |
| Baudrate | Belangrijk, moet aan beide kanten overeenkomen | Geen seriële poort gebruikt | Niet relevant, data stroomt op USB-snelheid |
| Reset bij het openen van de poort | Ja op de Uno, Nano en Mega | Geen | Nee |
| Wanneer kiezen | Je hebt al een Arduino en hebt kant-en-klare bibliotheken nodig | Eenvoudige standalone apparaten | Je wilt aan beide kanten één taal (Python) |
De onderstaande MicroPython-code is de Pico-versie van het Arduino-voorbeeld hierboven: hij leest elke 200 ms de potentiometer op GP26, stuurt het resultaat in hetzelfde formaat time,value en accepteert dezelfde led-commando's. Het equivalent van Serial op de Arduino is hier print() en sys.stdin; dankzij select.poll() blijft de meetlus draaien terwijl hij op commando's wacht.
1# Pico'ya main.py adıyla kaydet / save it on the Pico as main.py
2import sys
3import select
4import time
5from machine import ADC, Pin
6
7led = Pin("LED", Pin.OUT) # Pico ve Pico W dahili LED / onboard LED on Pico and Pico W
8pot = ADC(26) # GP26 = ADC0, potansiyometre orta ucu / potentiometer wiper
9okuyucu = select.poll()
10okuyucu.register(sys.stdin, select.POLLIN) # USB'den veri gelince haber ver / notify when USB data arrives
11
12son = time.ticks_ms()
13while True:
14 if okuyucu.poll(0): # bekleyen komut var mı? / is a command waiting?
15 komut = sys.stdin.readline().strip()
16 if komut == "LED ON":
17 led.on()
18 print("OK LED ON")
19 elif komut == "LED OFF":
20 led.off()
21 print("OK LED OFF")
22 if time.ticks_diff(time.ticks_ms(), son) >= 200: # 200 ms'de bir ölçüm / one reading every 200 ms
23 son = time.ticks_ms()
24 print("{},{}".format(son, pot.read_u16())) # zaman,değer (0-65535) / time,value (0-65535)Sla de code met Thonny op de Pico op als main.py, sluit daarna Thonny en haal de USB-kabel van de Pico los en steek hem er weer in: Thonny gebruikt zelf de seriële poort van de Pico, dus je Python-script kan de poort niet openen zolang Thonny verbonden is, en Thonny stopt bij het verbinden ook het draaiende programma; na de herstart draait main.py automatisch. De baudrate maakt op de USB-poort van de Pico niet uit; welke waarde je in Python ook opgeeft, de data stroomt op USB-snelheid. read_u16() geeft waarden van 0 tot 65535, dus bereken de spanning met deger * 3.3 / 65535. Omdat de Pico non-stop meetregels stuurt, kan readline() in het commandoscript hierboven een meting teruggeven in plaats van het antwoord; blijf bij de Pico lezen tot je een regel krijgt die met OK begint. Dit voorbeeld heeft geen HAZIR-regel en geen PWM- of READ-commando's; voeg ze toe aan de Pico-code als je ze nodig hebt. Wees voorzichtig als je binaire data vanaf de computer stuurt: de byte 0x03 betekent Ctrl+C in MicroPython en stopt je programma; dat kun je uitschakelen met micropython.kbd_intr(-1). Ben je nieuw met de Pico, dan zijn Wat is de Raspberry Pi Pico? en MicroPython-basis een goed begin.
Projectideeën met Arduino en Python
- Logger voor temperatuur en luchtvochtigheid: schrijf de metingen van een DHT11 één keer per minuut naar CSV en teken een week van het klimaat in je kamer in Excel of met pandas.
- Lampbediening vanaf je computer: stuur een relaismodule aan met AAN- en UIT-commando's vanuit Python en combineer dat met een timer of spraakcommando's.
- Live afstandsgrafiek: teken de afstand die een HC-SR04 meet met matplotlib. Draai je de sensor met een servo, dan kun je met dezelfde methode ook een radarscherm tekenen.
- Statusweergave van de pc: laat Python met de bibliotheek psutil het cpu- en geheugengebruik lezen en naar de Arduino sturen, die het toont op een OLED-display.
- Camera die een gezicht volgt: OpenCV vindt de positie van een gezicht in het beeld, Python zet die om in een hoek en verstuurt hem, en de Arduino draait de camera met een servomotor.
- Je eigen sneltoetsenbord: laat knoppen op de Arduino bij indrukken een regel sturen en laat Python die lezen en een programma openen of een sneltoets uitvoeren op de computer.
Veelgemaakte fouten en hoe je ze oplost
| Fout of symptoom | Oorzaak | Oplossing |
|---|---|---|
| ModuleNotFoundError: No module named 'serial' | pyserial is niet geïnstalleerd voor de Python-interpreter die het script uitvoert; VS Code of Thonny gebruikt misschien een andere Python | Voer python -m pip install pyserial uit met dezelfde interpreter en selecteer de juiste interpreter in je editor |
| AttributeError: module 'serial' has no attribute 'Serial' | Het verkeerde seriële pakket is geïnstalleerd of je bestand heet serial.py | pip uninstall serial en pip install pyserial; hernoem je bestand |
| could not open port 'COM3': PermissionError(13, 'Access is denied.', None, 5) | De poort is geopend in een ander programma: Serial Monitor, Serial Plotter of een tweede script | Sluit het andere programma; gebruik de with-constructie in je script |
| could not open port 'COM5': FileNotFoundError(2, 'The system cannot find the file specified.', None, 2) | Verkeerde poortnaam of het board is niet aangesloten | Vind de juiste naam met python -m serial.tools.list_ports -v |
| [Errno 13] Permission denied: '/dev/ttyACM0' | Je Linux-gebruiker heeft geen toestemming voor de seriële poort | sudo usermod -a -G dialout $USER en log daarna uit en weer in |
| Onzintekens of UnicodeDecodeError | Verschillende baudrates, of ruis tijdens het opstarten | Gebruik aan beide kanten dezelfde snelheid; voeg decode(errors="ignore") en reset_input_buffer() toe |
| readline() geeft altijd b'' terug | De Arduino stuurt geen regeleinde (print in plaats van println), verkeerde poort, of het board is nog aan het opstarten | Gebruik println, controleer de poort en snelheid, verhoog de timeout |
| ValueError: invalid literal for int() with base 10 | Een gedeeltelijke, lege of onverwachte regel werd omgezet naar een getal | Zet de omzetting in try/except en controleer het aantal kolommen |
| De eerste commando's worden genegeerd | De Uno is gereset toen de poort openden en het commando ging naar de bootloader | Wacht op de regel HAZIR of wacht 2 seconden na het openen van de poort |
| De grafiek loopt achter op de werkelijkheid | Er wordt maar één regel per frame gelezen, waardoor data zich in de buffer opstapelt | Lees elke regel met de in_waiting-lus en stuur minder vaak |
| Code wordt niet geüpload terwijl het script draait | Python houdt de poort vast | Stop het script met Ctrl+C en upload dan |
Arduino en Python via de seriële poort met elkaar laten praten is de snelste manier om van een eenvoudig sensorproject een systeem te maken dat data logt, grafieken tekent en vanaf je computer kan worden bestuurd. Lees eerst één waarde uit en druk die af, sla hem dan op in CSV en voeg als laatste commando's en grafieken toe; zorg bij elke stap dat de baudrate en het regeleinde aan beide kanten overeenkomen. In de BlueGrays-app vind je stap-voor-stap-projecten met schakelschema's en code om licht te meten met een LDR, temperatuur en luchtvochtigheid met een DHT11, afstand met een HC-SR04 en voor seriële communicatie tussen twee Arduino's, zodat je snel de databron bouwt die je met Python uitleest.
Veelgestelde vragen
Kun je Arduino in Python programmeren?
Python draait niet in een Arduino Uno, Nano of Mega; deze boards worden geprogrammeerd in de op C++ gebaseerde Arduino-taal in de Arduino IDE. Python draait op de computer en praat via de seriële poort met pyserial met het board; je kunt ook het voorbeeld StandardFirmata uploaden en de pins rechtstreeks vanuit Python aansturen met een bibliotheek als pyFirmata2. Wil je dat Python op het board zelf draait, kies dan een Raspberry Pi Pico of een ESP32, die MicroPython ondersteunen.
Hoe installeer ik pyserial?
Voer python -m pip install pyserial uit in een terminal en schrijf import serial in je code. Het pakket heet pyserial, maar de module die je importeert heet serial; pip install serial installeert een heel ander pakket en leidt tot een AttributeError. Op Linux moet je je gebruiker ook toevoegen aan de groep dialout.
Hoe vind ik op welke COM-poort mijn Arduino zit?
Kijk bij Tools > Port in de Arduino IDE of voer python -m serial.tools.list_ports -v uit in een terminal. In Windows toont ook het onderdeel Poorten (COM en LPT) in Apparaatbeheer de poort. Weet je het niet zeker, haal dan het board los en toon de poorten opnieuw; de poort die verdwijnt, hoort bij de Arduino.
Hoe stuur ik gegevens van Python naar Arduino?
Open de poort met serial.Serial en stuur bytes zoals ser.write(b"LED ON\n"); vergeet niet tekst om te zetten met encode() en een regeleinde toe te voegen. Controleer aan de Arduino-kant met Serial.available() of er data binnenkomt en lees de regel met Serial.readStringUntil('\n'). Omdat de Uno reset wanneer de poort opent, wacht je ongeveer 2 seconden voordat je het eerste commando stuurt.
Kan ik de Serial Monitor van Arduino en Python tegelijk gebruiken?
Nee, een seriële poort kan maar door één programma tegelijk worden geopend; het tweede programma krijgt de fout Access is denied of Resource busy. Je kunt de binnenkomende data in Python verwerken en tegelijk op het scherm afdrukken. Heb je twee aparte kanalen nodig, sluit dan een tweede USB-TTL-converter aan op de Arduino en maak met SoftwareSerial een tweede seriële poort.
Waarom reset mijn Arduino als Python de poort opent?
Op de Uno, Nano en Mega is de DTR-lijn van de USB-chip via een condensator verbonden met de RESET-pin, dus het board herstart elke keer dat de poort opent; deze schakeling is nodig zodat de IDE code kan uploaden. Wacht 2 seconden na het openen van de poort, of wacht op een regel van de Arduino waarin staat dat hij klaar is. Om de reset helemaal te voorkomen kun je een condensator van 10 µF tussen RESET en GND plaatsen, maar die moet je verwijderen voordat je uploadt.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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.

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.

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.

LED bedienen met je telefoon via Bluetooth
Een kleine oefening voor het aan- en uitzetten van de lampen in je kamer met je telefoon.

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.
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

