Wat is MicroPython? Basiscommando's, REPL en eerste programma's
Wat is MicroPython en hoe verschilt het van Python? REPL, machine.Pin, PWM, ADC, I2C, ticks_ms, main.py, Thonny, mpremote, mip, Pico en ESP32 instellen.
MicroPython is een kleine, snelle herimplementatie van de programmeertaal Python 3 voor microcontrollers. Zodra je MicroPython op een board zoals de Raspberry Pi Pico of ESP32 zet, voert het board zelf Python-code uit: je typt een commando zonder compileerstap en ziet de led meteen oplichten. Als je Python op school of op je computer hebt geleerd, kun je dezelfde syntaxis gebruiken om pins uit te lezen, motoren aan te sturen, sensordata te verzamelen en verbinding te maken met wifi.
In deze gids leer je hoe MicroPython verschilt van gewone Python, wat de REPL is waarmee je direct met het board praat, en welke modules je het vaakst gebruikt, namelijk machine.Pin, PWM, ADC en I2C, met voorbeeldcode. Daarna zie je het verschil tussen time.sleep en ticks_ms, de bestanden main.py en boot.py die bij het opstarten draaien, bestanden uploaden met Thonny en mpremote, bibliotheken toevoegen met mip en firmware flashen op de Pico en ESP32. In het laatste deel zetten we MicroPython naast Arduino C++.

Wat is MicroPython en hoe verschilt het van Python?
MicroPython is een open-sourceproject dat Damien George in 2013 startte voor één klein board en dat tegenwoordig tientallen microcontrollers ondersteunt. De firmware die je op het board zet bevat de Python-interpreter, de kernmodules en een klein bestandssysteem. Je code wordt op het board eerst omgezet in bytecode, waarna de interpreter die bytecode stap voor stap uitvoert. Omdat je niet het hele Python van je computer in een paar honderd KB RAM kunt proppen, blijft de taal gelijk maar zijn de meeste bibliotheken ingekort of helemaal afwezig. Daar staat iets tegenover dat desktop-Python niet heeft: de module machine, die directe toegang tot de hardware geeft.
| Onderwerp | Python (computer) | MicroPython (board) |
|---|---|---|
| Waar het draait | Een computer met gigabytes aan RAM | Een microcontroller met honderden KB RAM |
| Standaardbibliotheek | Heel groot: datetime, threading, urllib... | Een kleine subset: time, os, json, re, struct, random, math... |
| Pakketten | numpy, pandas en duizenden andere via pip | Geen numpy of pandas; micropython-lib-pakketten via mip |
| Toegang tot hardware | Geen, extra bibliotheken nodig | De module machine: Pin, PWM, ADC, I2C, SPI, UART, Timer |
| Kommagetallen (floats) | 64-bits (ongeveer 15 cijfers) | 32-bits op de Pico en ESP32 (ongeveer 7 cijfers) |
| Tijd | time.time(), datetime | time.sleep_ms(), time.ticks_ms(), machine.RTC |
| Het programma starten | Je start het vanaf de opdrachtregel | boot.py en main.py draaien vanzelf bij het opstarten |
Boards die MicroPython draaien
| Board | Firmwarebestand | Totaal RAM | Opmerking |
|---|---|---|---|
| Raspberry Pi Pico (RP2040) | RPI_PICO (.uf2) | 264 KB | Het makkelijkste board om mee te beginnen |
| Raspberry Pi Pico W | RPI_PICO_W (.uf2) | 264 KB | network-module voor wifi; de gewone Pico-firmware schakelt hier geen wifi in |
| Raspberry Pi Pico 2 (RP2350) | RPI_PICO2 (.uf2) | 520 KB | Sneller, meer geheugen |
| ESP32 (WROOM) | ESP32_GENERIC (.bin) | 520 KB (wifi gebruikt een deel) | Wifi en Bluetooth; veel meer geheugen op modellen met PSRAM |
| ESP8266 (NodeMCU, Wemos D1 Mini) | ESP8266_GENERIC (.bin) | Ongeveer 80 KB | Werkt, maar het geheugen is krap; kies voor nieuwe projecten een ESP32 |
| Arduino Uno (ATmega328P) | Geen | 2 KB | Kan geen MicroPython draaien; wordt in C++ geprogrammeerd |
MicroPython-firmware flashen op de Pico en ESP32
- Pico: Houd de knop BOOTSEL op het board ingedrukt terwijl je de USB-kabel aansluit en laat hem dan los. Op je computer verschijnt een schijf met de naam RPI-RP2 (RP2350 bij de Pico 2).
- Download het juiste .uf2-bestand voor je board van de officiële downloadpagina van MicroPython (RPI_PICO voor de Pico, RPI_PICO_W voor de Pico W) en sleep het naar die schijf.
- Als het kopiëren klaar is, herstart het board vanzelf en verdwijnt de schijf; MicroPython is geïnstalleerd. Kies in Thonny onder Tools > Options > Interpreter de optie MicroPython (Raspberry Pi Pico).
- ESP32: Als Python op je computer is geïnstalleerd, typ je op de opdrachtregel pip install esptool. Sluit het board aan en zoek de poort op (bijvoorbeeld COM3 op Windows, /dev/ttyUSB0 op Linux).
- Wis eerst het flashgeheugen: esptool.py --chip esp32 --port COM3 erase_flash. Als het board geen verbinding maakt, houd je de knop BOOT ingedrukt terwijl het commando draait.
- Schrijf de firmware: esptool.py --chip esp32 --port COM3 --baud 460800 write_flash -z 0x1000 ESP32_GENERIC-....bin. Bij de ESP32-S3 en ESP32-C3 is het adres 0x0. De optie Install or update MicroPython (esptool) in Thonny doet hetzelfde vanuit een venster.
De REPL: direct met het board praten
De REPL (Read-Eval-Print Loop) is de opdrachtregel die het board voor je opent via de seriële poort. De prompt >>> die je onderin het venster Shell van Thonny ziet, betekent dat de REPL op je wacht. Typ 1 + 1 en het board rekent en geeft 2 terug; typ from machine import Pin gevolgd door Pin("LED", Pin.OUT).value(1) en de led van de Pico gaat op datzelfde moment branden. Er is geen snellere manier dan de REPL om een sensorwaarde uit te lezen, te controleren of een pin goed is aangesloten of te onderzoeken hoe een bibliotheek werkt, zonder te wachten op compileren en uploaden.
| Sneltoets of commando | Wat het doet |
|---|---|
| Ctrl+C | Stopt het lopende programma (KeyboardInterrupt) en keert terug naar de REPL |
| Ctrl+D | Soft reset; boot.py en main.py draaien opnieuw |
| Ctrl+E | Paste-modus: plak lange code zonder de inspringing te verstoren, voer uit met Ctrl+D |
| Tab | Automatisch aanvullen; typ machine. en druk op Tab om alles in de module te tonen |
| help("modules") | Toont alle modules in de firmware |
| import gc; gc.mem_free() | Toont het vrije RAM dat je programma kan gebruiken, in bytes |
| import os; os.listdir() | Toont de bestanden op het board |
Eerste programma en het equivalent in Arduino C++
1# İlk program: dahili LED'i yakıp söndür / First program: blink the onboard LED
2from machine import Pin
3import time
4
5led = Pin("LED", Pin.OUT) # Pico ve Pico W; ESP32'de Pin(2, Pin.OUT) / Pico and Pico W; Pin(2, Pin.OUT) on ESP32
6
7while True:
8 led.value(1) # yak / on
9 time.sleep(0.5) # saniye cinsinden / in seconds
10 led.value(0) # söndür / off
11 time.sleep(0.5)1// Aynı program Arduino C++ ile / The same program in Arduino C++
2void setup() {
3 pinMode(LED_BUILTIN, OUTPUT);
4}
5
6void loop() {
7 digitalWrite(LED_BUILTIN, HIGH);
8 delay(500); // milisaniye cinsinden / in milliseconds
9 digitalWrite(LED_BUILTIN, LOW);
10 delay(500);
11}De twee programma's doen hetzelfde, maar zijn anders opgebouwd. MicroPython heeft geen setup() of loop(): het bestand wordt één keer van boven naar beneden uitgevoerd en de eindeloze lus bouw je zelf met while True:. In plaats van accolades en puntkomma's gebruikt het inspringing; elke regel in de lus moet evenveel inspringen (meestal 4 spaties). Ook de wachttijd heeft een andere eenheid: time.sleep(0.5) rekent in seconden, terwijl delay(500) van Arduino in milliseconden rekent. In MicroPython gebruik je time.sleep_ms() voor milliseconden en time.sleep_us() voor microseconden. De basis van de Arduino-kant staat in Basisprincipes van Arduino-programmeren.
machine.Pin: digitale in- en uitgang
| MicroPython | Equivalent in Arduino C++ | Beschrijving |
|---|---|---|
| led = Pin(15, Pin.OUT) | pinMode(15, OUTPUT) | Maakt de pin een uitgang |
| led.value(1) of led.on() | digitalWrite(15, HIGH) | Zet de pin op HIGH; value(0) of off() zet hem op LOW |
| buton = Pin(14, Pin.IN, Pin.PULL_UP) | pinMode(14, INPUT_PULLUP) | Ingang met de interne pull-upweerstand |
| buton.value() | digitalRead(14) | Geeft 0 of 1 terug |
| led.toggle() | digitalWrite(15, !digitalRead(15)) | Keert de toestand om; beschikbaar op de Pico, gebruik value(not led.value()) op de ESP32 |
| buton.irq(trigger=Pin.IRQ_FALLING, handler=f) | attachInterrupt(..., f, FALLING) | Roept de functie f aan wanneer de pin verandert |
time.sleep en ticks_ms: tijd meten zonder te blokkeren
time.sleep() laat het board volledig wachten; ondertussen wordt er geen knop gelezen en geen sensor gecontroleerd. Om meerdere taken tegelijk uit te voeren gebruik je het MicroPython-equivalent van de millis()-aanpak van Arduino: time.ticks_ms() geeft de milliseconden sinds het opstarten en time.ticks_diff(new, old) berekent het verschil tussen twee momenten. Het is belangrijk dat je het verschil met ticks_diff bepaalt en niet met gewone aftrekking; de teller begint opnieuw na een bepaalde waarde en gewone aftrekking geeft dan een verkeerd resultaat. De code hieronder laat de led knipperen zonder te blokkeren en luistert via een interrupt (IRQ) naar een knop; elke druk verandert de knippersnelheid.
1# delay kullanmadan iki iş: LED yanıp söner, buton kesmeyle modu değiştirir
2# Two jobs without blocking: the LED blinks, a button interrupt switches the mode
3from machine import Pin
4import time
5
6led = Pin(15, Pin.OUT) # LED + 220 Ω, GP15
7buton = Pin(14, Pin.IN, Pin.PULL_UP) # buton GP14 ile GND arasında / button between GP14 and GND
8
9hizli = False
10son_basma = 0
11son_degisim = time.ticks_ms()
12
13def buton_kesme(pin): # kesme fonksiyonu kısa olmalı / keep the handler short
14 global hizli, son_basma
15 simdi = time.ticks_ms()
16 if time.ticks_diff(simdi, son_basma) > 200: # 200 ms debounce / 200 ms debounce
17 son_basma = simdi
18 hizli = not hizli
19
20buton.irq(trigger=Pin.IRQ_FALLING, handler=buton_kesme) # basınca HIGH'dan LOW'a iner / goes HIGH to LOW when pressed
21
22while True:
23 aralik = 100 if hizli else 500
24 if time.ticks_diff(time.ticks_ms(), son_degisim) >= aralik: # taşmaya karşı güvenli / safe against wrap-around
25 son_degisim = time.ticks_ms()
26 led.value(not led.value())
27 # burada başka işler yapılabilir / other work can run herePWM: helderheid, servo's en geluid
1# PWM: LED parlaklığı ve servo açısı / PWM: LED brightness and servo angle
2from machine import Pin, PWM
3import time
4
5led = PWM(Pin(15))
6led.freq(1000) # 1 kHz: titreme görünmez / no visible flicker
7
8for d in range(0, 65536, 2048): # duty_u16: 0 (kapalı) ... 65535 (tam) / 0 (off) ... 65535 (full)
9 led.duty_u16(d)
10 time.sleep_ms(20)
11led.duty_u16(0)
12
13servo = PWM(Pin(16))
14servo.freq(50) # servolar 50 Hz (20 ms) ister / servos expect 50 Hz (20 ms)
15
16def servo_aci(derece):
17 us = 500 + derece * 2000 // 180 # 0° = 0,5 ms, 180° = 2,5 ms; servona göre ayarla / tune for your servo
18 servo.duty_ns(us * 1000)
19
20for a in (0, 90, 180, 90):
21 servo_aci(a)
22 time.sleep(1)Het PWM-object schakelt een pin heel snel aan en uit om een gemiddeld vermogen in te stellen. freq() bepaalt hoe vaak per seconde dit gebeurt en duty_u16() bepaalt hoe lang de pin aan blijft met een getal tussen 0 en 65535; 32768 is ongeveer 50 procent. Deze schaal geeft veel fijnere stappen dan het bereik 0–255 van analogWrite in Arduino. Servo's verwachten een signaal van 50 Hz en een pulsbreedte tussen 0,5 en 2,5 ms; duty_ns() stelt de pulslengte direct in nanoseconden in, waardoor servocode veel eenvoudiger wordt. Je kunt ook noten spelen door een passieve buzzer verschillende freq()-waarden te geven. Duty cycle en frequentie worden uitgebreid uitgelegd in Wat is PWM.
ADC: analoog uitlezen
1# ADC: potansiyometre ve Pico'nun dahili sıcaklık sensörü
2# ADC: a potentiometer and the Pico's internal temperature sensor
3from machine import ADC, Pin
4import time
5
6pot = ADC(Pin(26)) # GP26 = ADC0; ESP32'de ADC(Pin(34)) / ADC(Pin(34)) on ESP32
7yonga = ADC(4) # 4. kanal: dahili sıcaklık / channel 4: internal temperature
8
9def ortalama(adc, n=16): # gürültüyü azalt / reduce noise
10 toplam = 0
11 for _ in range(n):
12 toplam += adc.read_u16()
13 return toplam // n
14
15while True:
16 ham = ortalama(pot) # 0-65535 (12 bit ölçüm 16 bite ölçeklenir) / 12-bit reading scaled to 16 bits
17 volt = ham * 3.3 / 65535
18 v_t = ortalama(yonga) * 3.3 / 65535
19 derece = 27 - (v_t - 0.706) / 0.001721 # RP2040 veri sayfasındaki formül / formula from the RP2040 datasheet
20 print("Pot: {} ({:.2f} V) Yonga / chip: {:.1f} C".format(ham, volt, derece))
21 time.sleep(1)read_u16() geeft op elk board een waarde tussen 0 en 65535 terug, zodat dezelfde code op de Pico en de ESP32 draait. De ADC van de Pico is eigenlijk 12-bits en de meting wordt geschaald naar 16 bits. De Pico heeft drie analoge pins die je zelf kunt gebruiken: GP26 (ADC0), GP27 (ADC1) en GP28 (ADC2); het vierde kanaal is de temperatuursensor in de chip en meet de temperatuur van de chip, niet die van de kamer. Op de ESP32 heb je adc.atten(ADC.ATTN_11DB) nodig om het volledige bereik van 0–3,3 V te lezen, en de ADC2-pins zijn niet bruikbaar zolang wifi aan staat, dus kies de ADC1-pins tussen GPIO 32 en 39. Het gemiddelde van 16 metingen in de code vermindert de ADC-ruis merkbaar. Begrippen zoals resolutie en referentiespanning komen aan bod in Wat is een ADC.
I2C: sensoren en displays aansluiten
1# I2C: hattı tara ve SSD1306 OLED'e yaz / I2C: scan the bus and write to an SSD1306 OLED
2from machine import Pin, I2C
3import ssd1306 # önce: mpremote mip install ssd1306 / first: mpremote mip install ssd1306
4
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000) # Pico; ESP32'de I2C(0, sda=Pin(21), scl=Pin(22))
6adresler = i2c.scan()
7print("Bulunan / found:", [hex(a) for a in adresler]) # OLED genelde 0x3c / OLED is usually 0x3c
8
9if 0x3C in adresler:
10 oled = ssd1306.SSD1306_I2C(128, 64, i2c)
11 oled.fill(0)
12 oled.text("MicroPython", 0, 0)
13 oled.text("I2C: " + hex(adresler[0]), 0, 16)
14 oled.show()I2C(0, sda=..., scl=...) start de hardware-I2C-eenheid op de pins die je kiest en scan() geeft een lijst met de adressen van alle apparaten die op de bus antwoorden. Als een sensor niet werkt, is deze scan het eerste wat je doet: een lege lijst betekent dat het probleem in de bedrading zit en een onverwacht adres betekent dat je het adres in de code aanpast. Op de Pico liggen de pins die elke I2C-eenheid kan gebruiken vast; bijvoorbeeld de paren GP0-GP1, GP4-GP5 of GP8-GP9 werken voor I2C0, en een verkeerd paar geeft een ValueError. Op de ESP32 kan I2C aan bijna elke pin worden toegewezen. Details over displays staan in OLED-display en het protocol zelf in Wat is I2C.
main.py en boot.py: code die bij het opstarten draait
Als je in Thonny op Run drukt, draait de code alleen op dat moment zonder op het board te worden opgeslagen; zodra je de USB-kabel loskoppelt is ze weg. Wil je dat je code elke keer vanzelf draait als het board start, dan moet je het bestand als main.py op het board opslaan. Bij het opstarten draait eerst boot.py en daarna main.py. boot.py is voor eenmalige voorbereidingen zoals verbinding maken met wifi of de klok instellen; de ESP32-firmware maakt dit bestand zelf aan, terwijl het op de Pico meestal niet bestaat. Je eigenlijke programma staat altijd in main.py. Met import haal je functies uit andere bestanden in main.py en met open() sla je metingen op in het bestandssysteem van het board.
1# main.py: kart her açıldığında otomatik çalışır / runs automatically every time the board starts
2import time
3from machine import Pin
4
5time.sleep(3) # Ctrl+C ile durdurmak için güvenlik payı / a safety window for Ctrl+C
6led = Pin("LED", Pin.OUT)
7sayac = 0
8
9try:
10 while True:
11 sayac += 1
12 led.value(sayac % 2)
13 print("Calisiyor / running", sayac)
14 time.sleep(1)
15except KeyboardInterrupt: # Thonny'de Stop ya da Ctrl+C / Stop in Thonny or Ctrl+C
16 led.value(0)
17 print("Durduruldu / stopped")Bestanden uploaden: Thonny en mpremote
Als je net begint, is Thonny de makkelijkste manier: schrijf je code, kies File > Save as, kies in het venster dat opent Raspberry Pi Pico of MicroPython device en noem het bestand main.py. Open View > Files en je ziet de bestanden op je computer en op het board naast elkaar; met een rechtermuisklik kopieer je van de ene kant naar de andere. Voor wie de opdrachtregel prettig vindt en een editor zoals VS Code gebruikt, is mpremote het officiële hulpmiddel; installeer het met pip install mpremote en het maakt automatisch verbinding met het eerste MicroPython-board dat het vindt.
| mpremote-commando | Wat het doet |
|---|---|
| mpremote | Maakt verbinding met het eerste board dat het vindt en opent de REPL (afsluiten: Ctrl+X) |
| mpremote ls | Toont de bestanden op het board |
| mpremote cp main.py :main.py | Kopieert een bestand van de computer naar het board; de dubbele punt (:) staat voor het board |
| mpremote run test.py | Voert het bestand uit zonder het op het board op te slaan en toont de uitvoer |
| mpremote mip install ssd1306 | Downloadt de bibliotheek via het internet van de computer en installeert die in de map /lib van het board |
| mpremote reset | Herstart het board |
| mpremote connect COM3 ls | Maakt verbinding met het board op een bepaalde poort (zoals /dev/ttyACM0 op macOS en Linux) |
Bibliotheken toevoegen: mip
MicroPython heeft geen pip; in plaats daarvan gebruik je de kleine pakketbeheerder mip. Op een board dat online kan, zoals een Pico W of ESP32, maak je eerst verbinding met wifi en typ je daarna import mip en mip.install("ssd1306") in de REPL; het pakket wordt gedownload uit de officiële repository micropython-lib en in de map /lib van het board gezet. Met mip.install("github:user/repo") kun je ook een driver van GitHub installeren. Voor een Pico zonder wifi doe je hetzelfde vanaf je computer met het commando mpremote mip install of via het menu Tools > Manage packages van Thonny. Een driver uit één bestand (bijvoorbeeld een .py-bestand dat voor een sensor is geschreven) naar het board kopiëren werkt ook; zolang het bestand in de hoofdmap of in /lib staat, laad je het met import. De stappen voor de wifi-verbinding staan in Pico W wifi.
MicroPython of Arduino C++?
| Kenmerk | MicroPython | Arduino C++ |
|---|---|---|
| Taal | Python 3-syntaxis | C++ en de Arduino-core |
| Hoe het draait | Een interpreter op het board voert bytecode uit | Op de computer gecompileerd naar machinecode |
| Doorlooptijd | Direct in de REPL; opslaan duurt 1–2 seconden | Bij elke wijziging compileren en uploaden, 10–60 seconden |
| Snelheid | Pure Python-lussen zijn ruwweg 10–100 keer trager | Native snelheid |
| Timing | De garbage collector maakt af en toe korte pauzes | Voorspelbaar tot op de microseconde |
| Bestandssysteem | Ja: main.py, data- en instellingsbestanden | Nee; EEPROM of een extra bibliotheek nodig |
| Bibliotheken | micropython-lib en community-drivers | Het enorme ecosysteem van Arduino-bibliotheken |
| Boards | Pico, ESP32, ESP8266 | Bijna alle, ook Uno, Nano en Mega |
| Foutmeldingen | Duidelijke meldingen met regelnummers tijdens het uitvoeren | Compileerfouten; Serial.print om het tijdens het uitvoeren te volgen |
| Het beste in | Leren, snelle experimenten, wifi en dataverwerking | Nauwkeurige timing, boards met weinig geheugen, veel kant-en-klare bibliotheken |
In de praktijk bepaalt je project de keuze. Een sensor uitlezen en via wifi versturen, een webpagina serveren of een display aansturen kost in MicroPython minder regels en is sneller klaar. Signalen genereren met microsecondenprecisie, honderden leds heel snel bijwerken of alleen een klein board zoals een Uno hebben, geeft C++ een voorsprong. Je kunt een trage functie versnellen met de decorator @micropython.native en pauzes van de garbage collector verminderen door binnen lussen geen nieuwe lijsten en strings aan te maken. Voor de keuze van een board, zie ook Arduino of ESP32.
Veelvoorkomende fouten en oplossingen
| Fout of symptoom | Oorzaak | Oplossing |
|---|---|---|
| ImportError: no module named 'ssd1306' | De bibliotheek staat niet op het board | Installeer hem met mip of mpremote mip, of kopieer het .py-bestand naar het board |
| IndentationError | Inconsistente inspringing, spaties en tabs door elkaar | Gebruik overal in het bestand 4 spaties; Thonny doet dit voor je |
| OSError: [Errno 5] EIO (I2C) | Het apparaat antwoordt niet: bedrading, adres of voeding | Controleer het adres met scan(), controleer SDA en SCL |
| ValueError: bad SCL pin | De gekozen pins horen niet bij die I2C-eenheid | Kies het juiste I2C0- of I2C1-paar uit de pinout van de Pico |
| De code draait in Thonny, maar niet meer na het loskoppelen van USB | Het bestand is niet als main.py op het board opgeslagen | Gebruik Save as om het als main.py op het board op te slaan |
| MemoryError: memory allocation failed | Het RAM is vol: een grote lijst, een lange string of een grote buffer | Verwerk data in stukken, roep gc.collect() aan, gebruik bytearray |
| Thonny: Device is busy or does not respond | main.py zit in een lus zonder pauze, of een ander programma gebruikt de poort | Stop of Ctrl+C, sluit het andere programma, wis zo nodig het flashgeheugen |
MicroPython is de kortste weg naar de wereld van microcontrollers als je Python al kent: je ziet het resultaat zodra je een pin in de REPL probeert en een paar regels zijn genoeg om een sensor uit te lezen en met wifi te verbinden. Als je de kernmodules, het idee van main.py en timing zonder blokkeren met ticks_ms eenmaal beheerst, groeien je projecten snel. In de BlueGrays-app vind je Raspberry Pi Pico-projecten met leds, een stoplicht, knoppen en PWM, met stapsgewijze bedradingsschema's en MicroPython-code.
Veelgestelde vragen
Wat is MicroPython?
MicroPython is een kleine versie van de programmeertaal Python 3 die voor microcontrollers is gemaakt. Dankzij de firmware op het board draaien boards zoals de Raspberry Pi Pico en ESP32 Python-code rechtstreeks; met de module machine krijg je toegang tot pins, PWM, de ADC en I2C.
Is MicroPython hetzelfde als Python?
De syntaxis is gelijk, maar MicroPython is een uitgeklede subset van desktop-Python. Grote bibliotheken zoals numpy en pandas ontbreken, de standaardbibliotheek is beperkt en kommagetallen zijn 32-bits op de Pico en ESP32. Daar staat tegenover dat de module machine is toegevoegd voor directe hardwaretoegang.
Wat is beter, MicroPython of Arduino?
Dat hangt af van je doel. MicroPython is prettiger om te leren, voor snelle experimenten en voor projecten die data via wifi versturen; Arduino C++ draait sneller, heeft nauwkeurigere timing en biedt veel meer kant-en-klare bibliotheken. De Pico en ESP32 kun je op beide manieren programmeren.
Draait MicroPython op een Arduino Uno?
Nee. De ATmega328P-chip op de Arduino Uno heeft maar 2 KB RAM en 32 KB flash en de MicroPython-interpreter past er niet in. Wil je MicroPython gebruiken, kies dan een krachtiger board zoals de Raspberry Pi Pico of ESP32.
Hoe installeer ik een bibliotheek in MicroPython?
Typ op een board met internetverbinding import mip en mip.install("pakketnaam") in de REPL. Op boards zonder wifi doe je hetzelfde vanaf je computer met het commando mpremote mip install pakketnaam of met de pakketbeheerder van Thonny. Drivers uit één bestand naar het board kopiëren werkt ook.
Hoe sla ik code permanent op de Pico op?
Kies in Thonny via File > Save as de Raspberry Pi Pico en noem het bestand main.py. Elke keer dat het board start, draait eerst boot.py en daarna main.py vanzelf; zelfs als je de USB-kabel van de computer loskoppelt en in een andere 5V-bron steekt, blijft het programma draaien.
Projecten om hierna te bouwen
Alle projecten bekijken
Raspberry Pi Pico ingebouwde led laten knipperen (Pico en Pico W)
Het openingsproject van de Raspberry Pi Pico-serie! We laten de groene ingebouwde led van de Pico knipperen om te controleren of het board werkt: het klassieke "Hello World" als eerste experiment. Je hebt geen externe onderdelen nodig, alleen de Pico en een USB-kabel. De code is geschreven in MicroPython, de taal die officieel door de Raspberry Pi Foundation wordt ondersteund.

Raspberry Pi Pico: een externe led aansturen (breadboard)
De volgende stap na de ingebouwde led van de Pico: sluit een externe led aan op een breadboard en bestuur hem via pin GP14. Je leert hoe je elke GPIO-pin van de Pico als uitgang gebruikt, de polariteit van de led (lang pootje = anode/+, kort pootje = kathode/–) en waarom een stroombeperkende weerstand (220Ω) een must is. Zonder weerstand loopt er te veel stroom door de led en kan hij doorbranden.

Raspberry Pi Pico twee LED's om en om laten knipperen (blink-flip-patroon)
De volgende stap na de enkele led van de Pico: de klassieke flipflop-animatie, waarbij twee LED's om de beurt knipperen. De ene led gaat uit als de andere aan gaat, het meest basale voorbeeld van het aansturen van meerdere GPIO's. Twee LED's in verschillende kleuren (rood op GP14, groen op GP13) wisselen elke 500 ms. Met de methode Pin.toggle() van MicroPython blijft de code kort en leesbaar.

Raspberry Pi Pico-stoplicht (3 leds na elkaar)
We bouwen de logica van een echt stoplicht na met een rode, gele en groene led, het eerste Pico-project met 3 leds! Groen zegt 4 seconden "rijden", geel 1,5 seconde "maak je klaar", rood 3 seconden "stop" en rood+geel 1 seconde "optrekken" (het Europese stoplichtpatroon). Je leert functies definiëren (def all_off()), toestandsmachinelogica en het synchroniseren van meerdere GPIO's.

Raspberry Pi Pico: led bedienen met een knop (indrukken)
Het eerste invoerproject met de Pico — een knop uitlezen! De led brandt zolang je de knop indrukt en gaat uit als je loslaat. Dit is de grote stap na de ledanimaties: signalen van buiten naar de Pico. Je leert Pin.IN (invoermodus), Pin.PULL_UP (interne pull-upweerstand — standaard voor knoppen) en button.value() uitlezen. GP14 led, GP2 knop (interne PULL_UP). Ingedrukt = LOW (0), losgelaten = HIGH (1) — die omgekeerde logica lijkt eerst verwarrend, maar is de industriestandaard.

Raspberry Pi Pico-knop ontdenderen: IRQ vs software-polling
Als één druk op een knop je code 3-4 keer liet tellen, is contactdender de boosdoener: de metalen contacten van de knop gaan binnen microseconden vele malen open en dicht als ze elkaar raken! In dit project tellen we dezelfde knop op 2 manieren en vergelijken we ze naast elkaar in Serial: RAW-polling (vangt de dender op en telt fout) en IRQ + software-ontdendering (telt goed).

Raspberry Pi Pico PWM-led-fade (ademeffect)
De led knippert niet meer alleen, hij ademt! Met de PWM (Pulse Width Modulation) van de Raspberry Pi Pico wordt de helderheid van de led langzaam hoger en dan langzaam weer lager: een rustig "ademeffect" zoals het lampje van een slapende laptop. Je leert de klasse machine.PWM, de 16-bits helderheidswaarde van 0–65535 met duty_u16() en de PWM-frequentie.

Raspberry Pi Pico RGB-led-kleurcyclus (3-kanaals PWM)
Eén led, miljoenen kleuren! Een RGB-led bevat eigenlijk 3 aparte leds: rood, groen en blauw. Stel de helderheid van elk ervan apart in met de 3 PWM-kanalen van de Pico en de kleuren mengen: rood + groen = geel, groen + blauw = cyaan, alle drie = wit. In dit project doorloopt de led 8 kleuren.
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

