Gidsen · 16 min leestijd

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.

Arduino Uno R3-board en USB-aansluiting
Arduino Uno: de USB-aansluiting wordt zowel gebruikt om code te uploaden als voor seriële communicatie met Python; de TX- en RX-leds knipperen terwijl er data stroomt.

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:

InstellingArduino-kantPython-kantLet op
PortWordt automatisch aangemaakt via USBserial.Serial("COM3", ...)De poortnaam hangt af van het besturingssysteem
Snelheid (baud)Serial.begin(115200)serial.Serial(port, 115200)Als ze verschillen, krijg je onzintekens
Frame8 databits, geen pariteit, 1 stopbit (8N1)De standaardwaarde van pyserial is ook 8N1Je hoeft dit zelden te wijzigen
RegeleindeSerial.println() voegt \r\n toereadline() leest tot het \n tegenkomtVergeet de \n niet toe te voegen als je vanuit Python verstuurt
TimeoutSerial.setTimeout(), standaard 1000 mstimeout=1 (seconden)Met timeout=None wacht readline() eindeloos

pyserial installeren (Windows, macOS, Linux)

  1. 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.
  2. 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.
  3. Controleer de installatie: python -c "import serial; print(serial.__version__)" moet een versienummer als 3.5 tonen.
  4. Voor het gedeelte over de live grafiek heb je ook matplotlib nodig: python -m pip install matplotlib.
  5. 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.
PyPI heeft nog een ander pakket met de naam serial dat niets met seriële poorten te maken heeft. Als je pip install serial typt, komt je code langs de regel import serial, maar faalt daarna met AttributeError: module 'serial' has no attribute 'Serial'. Het juiste pakket is pyserial; verwijder het verkeerde met pip uninstall serial en installeer pyserial opnieuw. Dezelfde fout krijg je als je je eigen bestand serial.py noemt, want Python importeert dan jouw bestand in plaats van de bibliotheek.

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.

CH340 USB-TTL-convertermodule
De CH340-chip: op de meeste Arduino-kloonboards verbindt deze chip USB met de seriële poort; de fabrikant-ID (VID) is 1A86.
USB-chipWaar je hem vindtVID:PIDNaam in WindowsPoortnaam in Linux
ATmega16U2Originele Uno R3, Mega 25602341:0043 (Uno)Arduino Uno (COMx)/dev/ttyACM0
CH340Kloon-Uno-, Nano- en Mega-boards1A86:7523USB-SERIAL CH340 (COMx)/dev/ttyUSB0
CP2102ESP32 DevKit, NodeMCU10C4:EA60Silicon Labs CP210x USB to UART Bridge (COMx)/dev/ttyUSB0
FT232ROudere Nano's, FTDI-kabels0403:6001USB Serial Port (COMx)/dev/ttyUSB0
RP2040 (ingebouwde USB)Raspberry Pi Pico met MicroPython2E8A:0005USB 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.

Python
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:

C++ (Arduino IDE)
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

Python
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.

Opent het CSV-bestand in Excel als één kolom, dan komt dat door je regionale instellingen: in veel Europese landen verwacht Excel een puntkomma als scheidingsteken en een komma als decimaalteken. Gebruik csv.writer(dosya, delimiter=";") en schrijf de spanning met str(round(volt, 3)).replace(".", ","), of importeer het bestand in Excel via Gegevens > Uit tekst/CSV en kies zelf het scheidingsteken. Voor andere manieren om data in Excel te krijgen, zie Arduino-data naar Excel sturen.

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.

C++ (Arduino IDE)
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}
Python
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 OFF

De 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:

FormaatVoorbeeldregelVoordelenNadelen
Eén waarde512Eenvoudigste formaat; de Serial Plotter van Arduino tekent het directBij meerdere waarden is onduidelijk welke welke is
CSV2573,512,23.5Kort; Excel en pandas lezen het directDe kolomvolgorde moet aan beide kanten gelijk blijven
Sleutel:waardetemp:23.5,hum:41Leesbaar; de Serial Plotter toont de labelsLanger 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
Binair2 bytes: 0x02 0x00Snelste en kortste optieNiet 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.

BaudrateBytes per seconde (8N1)Regels van 12 bytes per secondeWanneer gebruiken
960096080Trage sensoren, lange kabels, oudere voorbeeldsketches
576005.760480Metingen met gemiddelde snelheid
11520011.520960Live 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

Python
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.

Met de condensator van 10 µF kan de Arduino IDE geen code uploaden, omdat uploaden dezelfde auto-resetschakeling gebruikt; haal de condensator eraf voordat je uploadt. Geeft Python device reports readiness to read but returned no data, dan is de verbinding met het board verbroken of gebruiken twee programma's tegelijk de poort. Als het board tijdens het draaien uit zichzelf reset, is meestal te weinig voeding de oorzaak; voed servo's en motoren met een aparte bron in plaats van met de 5V van de USB.

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?

Raspberry Pi Pico-ontwikkelboard
Raspberry Pi Pico: dankzij de ingebouwde USB-peripheral van de RP2040 heeft hij geen aparte USB-naar-seriële chip nodig; met MicroPython geïnstalleerd verschijnt hij direct als seriële poort op de computer.

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.

KenmerkArduino + Python op de pcPico + MicroPython (standalone)Pico + Python op de pc
Waar draait Python?Alleen op de computer; het board draait C++In de PicoAan beide kanten: MicroPython op de Pico, Python op de computer
Is een computer nodig?Ja, de data wordt op de computer verwerktNee, hij werkt op USB-voeding of een batterijJa
Beschikbare bibliothekenpyserial, matplotlib, pandas, numpy, OpenCVBeperkte modules zoals machine en timeElke bibliotheek op de computer
BaudrateBelangrijk, moet aan beide kanten overeenkomenGeen seriële poort gebruiktNiet relevant, data stroomt op USB-snelheid
Reset bij het openen van de poortJa op de Uno, Nano en MegaGeenNee
Wanneer kiezenJe hebt al een Arduino en hebt kant-en-klare bibliotheken nodigEenvoudige standalone apparatenJe 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.

MicroPython
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 symptoomOorzaakOplossing
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 PythonVoer 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.pypip 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 scriptSluit 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 aangeslotenVind 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 poortsudo usermod -a -G dialout $USER en log daarna uit en weer in
Onzintekens of UnicodeDecodeErrorVerschillende baudrates, of ruis tijdens het opstartenGebruik aan beide kanten dezelfde snelheid; voeg decode(errors="ignore") en reset_input_buffer() toe
readline() geeft altijd b'' terugDe Arduino stuurt geen regeleinde (print in plaats van println), verkeerde poort, of het board is nog aan het opstartenGebruik println, controleer de poort en snelheid, verhoog de timeout
ValueError: invalid literal for int() with base 10Een gedeeltelijke, lege of onverwachte regel werd omgezet naar een getalZet de omzetting in try/except en controleer het aantal kolommen
De eerste commando's worden genegeerdDe Uno is gereset toen de poort openden en het commando ging naar de bootloaderWacht op de regel HAZIR of wacht 2 seconden na het openen van de poort
De grafiek loopt achter op de werkelijkheidEr wordt maar één regel per frame gelezen, waardoor data zich in de buffer opstapeltLees elke regel met de in_waiting-lus en stuur minder vaak
Code wordt niet geüpload terwijl het script draaitPython houdt de poort vastStop het script met Ctrl+C en upload dan
Gaat er iets mis, haal dan eerst Python uit het plaatje en test de Arduino-sketch in de Serial Monitor op dezelfde baudrate. Als de regels daar goed zijn, ligt het probleem aan de Python-kant (poortnaam, snelheid, regeleinde of parsing); zijn ze daar ook onleesbaar, repareer dan eerst de Arduino-sketch. Wil de code helemaal niet uploaden, volg dan de stappen in de gids Arduino-uploadfout. Ben je benieuwd naar de hardwarekant van seriële communicatie, dus TX, RX en UART, kijk dan bij UART seriële communicatie.

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.

Alle projecten bekijken
Lichtsterkte meten met een LDR
AR-11Beginner

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.

4.6(83)
143
Afstand meten met HC-SR04 (Serial-weergave)
AR-27Beginner

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.

4.6(50)
82
Temperatuur en luchtvochtigheid met DHT11
AR-55Gemiddeld

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…

4.7(47)
83
Lichtsterkte meten met de ESP32 en een LDR-module
ES-11Beginner

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.

4.6(36)
55
Eenrichtingscommunicatie tussen 2 Arduino's
AR-57Gemiddeld
Premium

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.

4.4(37)
50
Tweerichtingscommunicatie tussen 2 Arduino's
AR-58Gemiddeld
Premium

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.

4.5(20)
26
LED bedienen met je telefoon via Bluetooth
AR-34Beginner
Premium

LED bedienen met je telefoon via Bluetooth

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

4.8(69)
91
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

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.

4.7(7)
12