Basis · 10 min leestijd

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

Raspberry Pi Pico met MicroPython
Raspberry Pi Pico: het makkelijkste board om met MicroPython te beginnen. Sleep gewoon het UF2-bestand erheen.

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.

OnderwerpPython (computer)MicroPython (board)
Waar het draaitEen computer met gigabytes aan RAMEen microcontroller met honderden KB RAM
StandaardbibliotheekHeel groot: datetime, threading, urllib...Een kleine subset: time, os, json, re, struct, random, math...
Pakkettennumpy, pandas en duizenden andere via pipGeen numpy of pandas; micropython-lib-pakketten via mip
Toegang tot hardwareGeen, extra bibliotheken nodigDe 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)
Tijdtime.time(), datetimetime.sleep_ms(), time.ticks_ms(), machine.RTC
Het programma startenJe start het vanaf de opdrachtregelboot.py en main.py draaien vanzelf bij het opstarten

Boards die MicroPython draaien

BoardFirmwarebestandTotaal RAMOpmerking
Raspberry Pi Pico (RP2040)RPI_PICO (.uf2)264 KBHet makkelijkste board om mee te beginnen
Raspberry Pi Pico WRPI_PICO_W (.uf2)264 KBnetwork-module voor wifi; de gewone Pico-firmware schakelt hier geen wifi in
Raspberry Pi Pico 2 (RP2350)RPI_PICO2 (.uf2)520 KBSneller, 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 KBWerkt, maar het geheugen is krap; kies voor nieuwe projecten een ESP32
Arduino Uno (ATmega328P)Geen2 KBKan geen MicroPython draaien; wordt in C++ geprogrammeerd

MicroPython-firmware flashen op de Pico en ESP32

  1. 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).
  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.
  3. 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).
  4. 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).
  5. 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.
  6. 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.
Bij het flashen van firmware worden het oude programma en de bestanden op het board gewist, ook code die je met de Arduino IDE hebt geüpload. Andersom wist het uploaden van code met de Arduino IDE naar een board met MicroPython ook MicroPython; om terug te gaan moet je de firmware opnieuw flashen. Als het bestandssysteem van de Pico beschadigd raakt of het board vastloopt, wist het officiële bestand flash_nuke.uf2 het flashgeheugen volledig. De pins van de Pico en een stapsgewijze uitleg van de eerste installatie staan in Wat is de Raspberry Pi Pico.

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 commandoWat het doet
Ctrl+CStopt het lopende programma (KeyboardInterrupt) en keert terug naar de REPL
Ctrl+DSoft reset; boot.py en main.py draaien opnieuw
Ctrl+EPaste-modus: plak lange code zonder de inspringing te verstoren, voer uit met Ctrl+D
TabAutomatisch 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++

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

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

MicroPython
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 here
Houd de interrupt-handler kort: zet alleen een vlag om of sla een tijdstip op en laat lange taken over aan de hoofdlus. Vergeet bij variabelen die je vanuit de interrupt wijzigt niet global bovenaan de functie te zetten; anders maakt Python binnen de functie een nieuwe lokale variabele met dezelfde naam aan en ziet de hoofdlus de wijziging nooit. De Arduino-kant van hetzelfde idee staat in millis vs delay.

PWM: helderheid, servo's en geluid

MicroPython
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

MicroPython
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

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

MicroPython
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")
Als main.py een strakke eindeloze lus zonder enige pauze bevat, kan Thonny geen verbinding met het board maken en meldt het Device is busy or does not respond. Druk eerst een paar keer op de knop Stop van Thonny of probeer Ctrl+C in de Shell. Lukt dat niet, dan moet je de Pico met BOOTSEL starten en wissen met flash_nuke.uf2, of bij de ESP32 het flashgeheugen wissen en de firmware opnieuw flashen. De opstartvertraging van 3 seconden in de code geeft je tijd om het programma te stoppen voordat je in die situatie belandt.

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-commandoWat het doet
mpremoteMaakt verbinding met het eerste board dat het vindt en opent de REPL (afsluiten: Ctrl+X)
mpremote lsToont de bestanden op het board
mpremote cp main.py :main.pyKopieert een bestand van de computer naar het board; de dubbele punt (:) staat voor het board
mpremote run test.pyVoert het bestand uit zonder het op het board op te slaan en toont de uitvoer
mpremote mip install ssd1306Downloadt de bibliotheek via het internet van de computer en installeert die in de map /lib van het board
mpremote resetHerstart het board
mpremote connect COM3 lsMaakt 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++?

KenmerkMicroPythonArduino C++
TaalPython 3-syntaxisC++ en de Arduino-core
Hoe het draaitEen interpreter op het board voert bytecode uitOp de computer gecompileerd naar machinecode
DoorlooptijdDirect in de REPL; opslaan duurt 1–2 secondenBij elke wijziging compileren en uploaden, 10–60 seconden
SnelheidPure Python-lussen zijn ruwweg 10–100 keer tragerNative snelheid
TimingDe garbage collector maakt af en toe korte pauzesVoorspelbaar tot op de microseconde
BestandssysteemJa: main.py, data- en instellingsbestandenNee; EEPROM of een extra bibliotheek nodig
Bibliothekenmicropython-lib en community-driversHet enorme ecosysteem van Arduino-bibliotheken
BoardsPico, ESP32, ESP8266Bijna alle, ook Uno, Nano en Mega
FoutmeldingenDuidelijke meldingen met regelnummers tijdens het uitvoerenCompileerfouten; Serial.print om het tijdens het uitvoeren te volgen
Het beste inLeren, snelle experimenten, wifi en dataverwerkingNauwkeurige 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 symptoomOorzaakOplossing
ImportError: no module named 'ssd1306'De bibliotheek staat niet op het boardInstalleer hem met mip of mpremote mip, of kopieer het .py-bestand naar het board
IndentationErrorInconsistente inspringing, spaties en tabs door elkaarGebruik overal in het bestand 4 spaties; Thonny doet dit voor je
OSError: [Errno 5] EIO (I2C)Het apparaat antwoordt niet: bedrading, adres of voedingControleer het adres met scan(), controleer SDA en SCL
ValueError: bad SCL pinDe gekozen pins horen niet bij die I2C-eenheidKies het juiste I2C0- of I2C1-paar uit de pinout van de Pico
De code draait in Thonny, maar niet meer na het loskoppelen van USBHet bestand is niet als main.py op het board opgeslagenGebruik Save as om het als main.py op het board op te slaan
MemoryError: memory allocation failedHet RAM is vol: een grote lijst, een lange string of een grote bufferVerwerk data in stukken, roep gc.collect() aan, gebruik bytearray
Thonny: Device is busy or does not respondmain.py zit in een lus zonder pauze, of een ander programma gebruikt de poortStop 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.

Alle projecten bekijken
Raspberry Pi Pico ingebouwde led laten knipperen (Pico en Pico W)
PI-1Beginner

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.

5.0(1)
10
Raspberry Pi Pico: een externe led aansturen (breadboard)
PI-2Beginner

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.

4.5(2)
7
Raspberry Pi Pico twee LED's om en om laten knipperen (blink-flip-patroon)
PI-3Beginner

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.

5.0(2)
19
Raspberry Pi Pico-stoplicht (3 leds na elkaar)
PI-4Beginner

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.

4.0(1)
12
Raspberry Pi Pico: led bedienen met een knop (indrukken)
PI-9Beginner
Premium

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.

11
Raspberry Pi Pico-knop ontdenderen: IRQ vs software-polling
PI-13Gemiddeld
Premium

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

12
Raspberry Pi Pico PWM-led-fade (ademeffect)
PI-14Beginner

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.

4
Raspberry Pi Pico RGB-led-kleurcyclus (3-kanaals PWM)
PI-15Beginner

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.

6