Raspberry Pi Pico-lesplan: 6 weken MicroPython in de klas
Raspberry Pi Pico-lesplan: 6 weken MicroPython-lessen van 40 minuten met gratis projecten, Thonny-installatie, een materiaallijst voor 24 leerlingen en een voorbeeldles.
Zoek je een Raspberry Pi Pico-lesplan? Dit is het korte antwoord: 6 weken, één les van 40 minuten per week, leerlingen in tweetallen en elke week precies één nieuw MicroPython-concept. In week 1 laten leerlingen de ingebouwde led branden met één regel in de REPL van Thonny. Daarna volgen variabelen en timing, functies, knoppen en voorwaarden, geluid en een afstandssensor met PWM, en in de laatste week een piano met vijf knoppen, gebouwd met een lijst en een for-lus. Het project van elke week is gratis in BlueGrays, met schakelschema, onderdelenlijst en code, dus leerlingen hebben geen Premium nodig. Het plan gebruikt de Raspberry Pi Pico of Pico W met Thonny en is geschreven voor middelbare scholieren die nog nooit code hebben geschreven.
Eerst bekijken we waarom de Pico en MicroPython zo goed werken in een klaslokaal. Daarna volgt de voorbereiding vóór de eerste les: het MicroPython UF2-bestand, de BOOTSEL-knop, het kiezen van de interpreter in Thonny en waar je op school op moet letten bij computers. Vervolgens krijg je het plan per week met het Arduino C++-equivalent van elk concept, een materiaallijst voor een klas van 24, een voorbeeldles per minuut, drie korte codevoorbeelden, een beoordelingstabel en oplossingen voor de problemen die in de klas het vaakst voorkomen. De 8-wekenversie van deze aanpak met Arduino en blokken behandelden we in het lesplan programmeren met blokken; dit plan herhaalt dat niet en is bedoeld voor klassen die meteen met tekstcode willen beginnen of na blokken verder willen met Python.

Waarom de Raspberry Pi Pico en MicroPython?
De Pico is een klein microcontrollerboard dat Raspberry Pi heeft gebouwd rond een eigen RP2040-chip. Het is geen computer; net als een Arduino draait hij steeds hetzelfde programma. In de klas heeft hij drie sterke punten. Het eerste is MicroPython, een afgeslankte versie van Python voor microcontrollers. Het is makkelijk te lezen en heeft geen puntkomma's of accolades, dus leerlingen die Python kennen van informatica gebruiken dezelfde taal om een led of buzzer aan te sturen. Het tweede is dat er niet gecompileerd hoeft te worden: zodra je in Thonny op Run drukt, draait de code op het board en hoef je na elke kleine wijziging niet te wachten op compileren en uploaden. In een les van 40 minuten betekent dat veel meer pogingen in dezelfde tijd. Het derde is de REPL: typ één regel in de Shell van Thonny, druk op Enter en het board voert hem meteen uit. Als een leerling led.on() typt en de led gaat branden, begrijpt die binnen vijf minuten dat programmeren betekent: het board opdrachten geven. De lage prijs en het feit dat het board direct in een breadboard past, maken tweetallen ook realistisch. Wanneer is de Arduino de makkelijkere keuze? Bij jongere leerlingen die net kunnen lezen, of als het grootste deel van je set uit 5V-modules bestaat, geeft beginnen met de Arduino en blokken minder verrassingen. Voor de specificaties en pinout van het board, zie wat de Raspberry Pi Pico is.
| Eigenschap | Raspberry Pi Pico + MicroPython | Arduino Uno + C++ |
|---|---|---|
| Pinspanning | 3,3 V (niet 5 V-tolerant) | 5 V |
| Taal en editor | MicroPython, Thonny | C++, Arduino IDE |
| Code uitvoeren | Direct als je op Run drukt, zonder compileren | Compileren en uploaden na elke wijziging |
| Regel voor regel testen (REPL) | Ja: >>> in de Shell van Thonny | Nee |
| Analoge ingangen | 3 pins (GP26–GP28), read_u16() 0–65535 | 6 pins (A0–A5), analogRead() 0–1023 |
| USB-poort | Micro USB | USB-B (Uno R3) |
| Op een breadboard | Pico H / WH hebben headers en passen er direct in | Board zit buiten het breadboard, bedraad met jumperdraden |
| Prijs | Meestal duidelijk goedkoper dan een Uno | Duurder |
Vóór de eerste les: MicroPython en Thonny
- Ken je board: de Pico, Pico W, Pico 2 en Pico 2 W hebben elk een ander MicroPython-bestand nodig. Controleer de opdruk op het board en download van de officiële MicroPython-downloadpagina het nieuwste .uf2-bestand voor precies dat board. Met het verkeerde bestand start het board niet of werkt wifi niet.
- Insteken terwijl je BOOTSEL ingedrukt houdt: houd de witte BOOTSEL-knop naast de USB-poort ingedrukt terwijl je de kabel in de computer steekt en laat dan los. Op de computer verschijnt een schijf met de naam RPI-RP2 (bij de Pico 2 heet die RP2350).
- Kopieer het UF2-bestand: sleep het .uf2-bestand naar die schijf. Het board herstart binnen een paar seconden en de schijf verdwijnt; dat is geen fout, het betekent dat MicroPython is geïnstalleerd. MicroPython blijft op het board staan, dus je hoeft het niet elke les opnieuw te installeren.
- Kies de interpreter in Thonny: selecteer in Tools > Options > Interpreter "MicroPython (Raspberry Pi Pico)" en laat de poort op automatische detectie staan. Dezelfde keuze maak je door rechtsonder in het Thonny-venster te klikken.
- Test de verbinding: je ziet het >>> prompt in de Shell onderaan. Typ print("hello") en druk op Enter; als je een antwoord krijgt, is het board klaar voor de les.
Laat de installatie op schoolcomputers niet voor de les zelf; overleg een week van tevoren met je IT-team. Thonny draait op Windows, macOS en Linux en wordt geleverd met een eigen Python, dus je hoeft geen aparte Python te installeren. Er is ook een draagbare versie voor Windows die helemaal geen installatie nodig heeft, wat veel scheelt in afgeschermde computerlokalen waar alleen IT software mag installeren. Windows 10 en 11 herkennen de Pico zonder extra driver als seriële poort (COM). Sommige scholen blokkeren USB-schijven; dan verschijnt de RPI-RP2-schijf misschien niet op leerlingcomputers, maar als je MicroPython van tevoren op je eigen computer op de boards hebt gezet, maakt dat niet uit, want de les gebruikt alleen de seriële verbinding. Laat leerlingen tot slot de twee opties in het opslaan-venster van Thonny zien: "Deze computer" slaat het bestand op de computer op, "Raspberry Pi Pico" slaat het op het board op. Tweetallen die niet weten welke ze hebben gekozen, vinden hun code in week 6 niet terug.
Het Raspberry Pi Pico-lesplan van 6 weken
Elke les is gepland op 40 minuten met tweetallen. Elk project in de tabel is gratis in BlueGrays en de projecten van de eerste drie weken hebben naast de code ook een blokkenweergave. De volgorde is bewust gekozen: eerst uitvoer (led), dan variabelen en timing, functies, daarna invoer en voorwaarden, geluid en een sensor met PWM, en ten slotte lijsten en lussen. Elke week voegt precies één nieuw idee toe aan het vorige. De laatste kolom toont hetzelfde concept in Arduino C++, wat een brug slaat voor leerlingen die later naar de Arduino overstappen; voor de C++-kant in detail, zie basis van Arduino-programmeren.
| Week | Doel | Gratis BlueGrays-project | Nieuw MicroPython-concept | Arduino C++-equivalent |
|---|---|---|---|---|
| 1 | Kennismaken met de Pico, eerste programma, digitale uitgang | Raspberry Pi Pico: ingebouwde led laten knipperen (Pico en Pico W), Raspberry Pi Pico: een externe led aansturen (GP14 + breadboard) | REPL (>>>), from machine import Pin, Pin(14, Pin.OUT), led.on() / led.off(), time.sleep(0.5), while True:, inspringen | pinMode(14, OUTPUT); digitalWrite(14, HIGH); delay(500); void loop() |
| 2 | Variabelen, timing, twee uitgangen | Raspberry Pi Pico: twee leds om en om (knipperpatroon, GP14 + GP13), Raspberry Pi Pico: politieflitser (rood + blauw, GP11 + GP12) | WAIT_MS = 300 (variabele), led.value(1), led.toggle(), sleep_ms(300) | int waitMs = 300; digitalWrite(13, !digitalRead(13)); delay(waitMs); |
| 3 | Minder herhaling: functies | Raspberry Pi Pico: stoplichtsimulator (3 leds na elkaar, GP11/GP12/GP13) | def all_off():, een functie aanroepen, decimale seconden met sleep(1.5) | void allOff() { … } ; delay(1500); |
| 4 | Invoer, voorwaarden en toestand | Raspberry Pi Pico: stoplicht met knop voor 4 standen (toestandsmachine, GP11-13 + GP4) | Pin(4, Pin.IN, Pin.PULL_UP), if / elif / else, mode = (mode + 1) % 4, time.ticks_ms() | pinMode(4, INPUT_PULLUP); if / else if / else; millis() |
| 5 | Sensor en geluid | Raspberry Pi Pico: parkeersensor (HC-SR04 + 3 leds + buzzer) | PWM(Pin(17)), freq(), duty_u16(), time_pulse_us(), def … return | tone(17, 1200); pulseIn(); return |
| 6 | Lijsten, for-lussen, eindproject | Raspberry Pi Pico: knoppenpiano (5 knoppen + buzzer + melodie-opnemer) | NOTE_HZ = (523, 587, 659, 698, 784), for … in, vijf knoppen met dezelfde code | int notes[] = {523, 587, 659, 698, 784}; for (int i = 0; i < 5; i++) |

Maak er tijdens het plan een regel van dat leerlingen aan het eind van elke week één waarde veranderen. In week 1 roept het project met de ingebouwde led de led aan met de naam "LED", zodat het op de Pico en de Pico W hetzelfde werkt; de externe led gaat naar GP14, dat is fysieke pin 19, en pin 18 er vlak naast is GND. In week 2 laat het verlagen van WAIT_MS in de politieflitser van 300 naar 80 zien dat één variabele het ritme van beide leds tegelijk verandert. In week 3 roept het stoplicht all_off() drie keer aan in de lus; laat leerlingen de functie verwijderen en hetzelfde met de hand schrijven, en zodra ze negen regels zien opstapelen, vertellen ze zelf waarom functies bestaan. Week 4 is een project op gemiddeld niveau: de knop is bedraad met PULL_UP, dus hij leest 0 als je hem indrukt, en elke druk laat de stand wisselen tussen normaal, alleen rood, knipperend geel en uit. De code is lang, dus lees hem eerst door met de stappen in het tabblad Code uitgelegd. In week 5 werkt de HC-SR04 op 5 V, dus vergeet niet ECHO via de spanningsdeler aan te sluiten; spelen met de waarden GREEN_CM 100, YELLOW_CM 50, RED_CM 25 en STOP_CM 10 geeft leerlingen een idee van een drempelwaarde. Hoe de sensor werkt lees je in het bericht HC-SR04-afstandssensor en hoe je geluid maakt met PWM in wat een buzzer is; gebruik een passieve buzzer, want het project verandert de frequentie. In week 6 speelt de piano vijf noten van DO tot SOL tussen 523 en 784 Hz, en als je de DO-toets een seconde ingedrukt houdt, begint het opnemen van een melodie. De volledige code is voor dit niveau lang; vraag leerlingen daarom niet alles over te typen, maar de frequenties in de lijst NOTE_HZ te veranderen en hun eigen toonladder te maken.
Afsluitende vragen voor elke week
- Week 1: Wat gebeurt er als je de regels led.on() en time.sleep(0.5) omwisselt? Waarom beginnen de regels onder while True: verder naar rechts?
- Week 2: Hoe verandert de flitser als je WAIT_MS verhoogt van 300 naar 1000? Welke twee regels vervangt toggle() in zijn eentje?
- Week 3: Hoeveel regels meer zou je schrijven zonder de functie all_off()? Wat is het verschil tussen een functie definiëren en een functie aanroepen?
- Week 4: Waarom geeft button.value() 0 als je een knop met PULL_UP indrukt? Als mode 3 is en je drukt op de knop, wat is mode dan?
- Week 5: Waarom sluiten we de ECHO-pin van de HC-SR04 niet rechtstreeks op de Pico aan? Wat laat de regel duty_u16(0) de buzzer doen?
- Week 6: Welke lijsten in de code moet je aanpassen om een zesde toets aan de piano toe te voegen?
Materiaallijst voor een klas van 24
Verdeel 24 leerlingen in tweetallen en je krijgt 12 groepen; met één reserve maak je 13 sets klaar. Omdat de Pico goedkoop is, zijn tweetallen in plaats van groepjes van drie op de meeste scholen mogelijk en heeft elke leerling meer tijd achter het toetsenbord; kies je voor groepjes van drie, verlaag de aantallen dan naar 9 sets. Elke groep heeft een computer nodig, omdat Thonny via USB met de Pico praat. Een telefoon of tablet gebruik je om het project van de week, het schakelschema en het tabblad Code uitgelegd open te houden in BlueGrays. Er hoeft niets gesoldeerd te worden; alles gaat in het breadboard.
| Onderdeel | Per groep | Voor de klas (12 groepen + 1 reserve) | Gebruikt in week |
|---|---|---|---|
| Raspberry Pi Pico H of Pico WH (headers gesoldeerd) | 1 | 13 | Alle |
| Micro-USB-datakabel | 1 | 13 | Alle |
| Breadboard (400 of 830 gaatjes) | 1 | 13 | Alle |
| Jumperdraden male-male | 20 | ongeveer 260 | Alle |
| Leds van 5 mm (rood, geel, groen, blauw) | 4 | ongeveer 60 | 1–5 |
| Weerstand van 220 Ω | 4 | ongeveer 60 | 1–5 |
| Drukknop (4 pootjes) | 5 | ongeveer 70 | 4, 6 |
| Passieve buzzer | 1 | 13 | 5, 6 |
| HC-SR04 ultrasone afstandssensor | 1 | 13 | 5 |
| Weerstand van 1 kΩ en 2 kΩ (ECHO-deler) | 1 + 1 | 13 + 13 | 5 |
| Computer met Thonny | 1 | 12 | Alle |
| Potentiometer van 10 kΩ (optioneel, voor ADC) | 1 | 13 | Snelle groepen |
Voorbeeldles: week 1, het eerste programma
Het onderstaande plan is voor week 1. De eerste les is de meest riskante, want hier komen installatieproblemen aan het licht. We gaan ervan uit dat je MicroPython van tevoren op de boards hebt gezet en dat Thonny op de computers is geïnstalleerd. In de andere weken kun je hetzelfde skelet gebruiken: warming-up, samen lezen, voorspelling, schakeling, de code uitvoeren, één waarde veranderen en een afsluitende vraag. Heb je een dubbele les van 80 minuten, rek dan de fase "één waarde veranderen" op en laat de tweetallen hun antwoorden op de afsluitende vraag presenteren.
| Tijd | Fase | Wat er gebeurt |
|---|---|---|
| 0–5 min | Warming-up | Vraag: wat moet je een board vertellen om de led te laten branden? De antwoorden komen op het bord. De boards worden uitgedeeld en de BOOTSEL-knop en USB-poort worden aangewezen. |
| 5–12 min | Eerste commando in de REPL | Thonny Shell op de beamer: from machine import Pin, led = Pin("LED", Pin.OUT), led.on(). Tweetallen typen dezelfde drie regels op hun eigen computer en zetten hem daarna uit met led.off(). |
| 12–18 min | Het project samen lezen | Open het project voor de ingebouwde led in BlueGrays. Lees eerst de blokken met Toon als blokken ingeschakeld, daarna de code; bespreek while True en het inspringen. |
| 18–22 min | Uitvoeren | Plak de code in Thonny en druk op Run (F5). De led knippert elke 0,5 seconden. Laat de Stop-knop zien om te stoppen. |
| 22–32 min | Schakeling met externe led | USB losmaken. GP14 (pin 19) → 220 Ω → lange pootje van de led, kort pootje → GND (pin 18). Voer de code van het project met de externe led uit. Rollen: bouwer en controleur. |
| 32–37 min | Eén waarde veranderen | Verander time.sleep(0.5) in 0.1 en daarna in 2. Tweetallen die willen kunnen de led naar GP15 verplaatsen en in de code 14 veranderen in 15. |
| 37–40 min | Afsluitende vraag | Eén vraag op papier: wat zou er gebeuren als de regels onder while True: niet verder naar rechts begonnen? De boards worden losgekoppeld en gaan terug in hun genummerde bakjes. |
Drie korte MicroPython-voorbeelden voor de klas
De ingebouwde led veroorzaakt de meeste verwarring tussen de Pico en de Pico W. Op de klassieke Pico zit de led aan GP25, daarom gebruiken oudere voorbeelden Pin(25). Op de Pico W zit de led aan de wifichip en heeft hij geen genummerde GP-pin, dus Pin(25) laat hem daar niet branden. De manier die op beide werkt, is de led bij zijn naam aanroepen: Pin("LED"). Actuele MicroPython-versies definiëren deze naam voor de Pico, de Pico W en de Pico 2, daarom gebruikt het project met de ingebouwde led in BlueGrays hem. Heeft je klas een mix van boards, dan kun je aan iedereen dezelfde code uitdelen. Als oude firmware de naam "LED" niet kent, is de oplossing het UF2-bestand bij te werken.
1from machine import Pin
2import time
3
4# "LED" adı Pico, Pico W ve Pico 2'de karttaki LED'i bulur / The name "LED" finds the onboard LED on Pico, Pico W and Pico 2
5led = Pin("LED", Pin.OUT)
6# Eski firmware'li klasik Pico'da: Pin(25, Pin.OUT) / Classic Pico with old firmware: Pin(25, Pin.OUT)
7# Pico W'de Pin(25) LED'i yakmaz / On the Pico W, Pin(25) does not light the LED
8
9while True:
10 led.toggle() # Durumu tersine çevir / Flip the state
11 time.sleep(0.5) # 0,5 saniye bekle / Wait 0.5 seconds
12De code voor de externe led gebruikt hetzelfde skelet; alleen het pinnummer verandert. Hier hebben we de wachttijd in een variabele met de naam WAIT gezet, die in week 2 de eerste regel wordt die leerlingen aanpassen. De variabele count en de regel print() schrijven elke keer dat de led gaat branden een getal naar de Shell van Thonny, zodat leerlingen op het scherm zien dat de lus echt draait. De 14 in de code is een GP-nummer, geen fysiek pinnummer; dat is waar leerlingen het vaakst de mist in gaan.
1from machine import Pin
2import time
3
4LED_PIN = 14 # LED'in bağlı olduğu GP pini (fiziksel pin 19) / GP pin the LED is wired to (physical pin 19)
5WAIT = 0.5 # Bekleme süresi, saniye / Wait time in seconds
6
7led = Pin(LED_PIN, Pin.OUT) # Pini çıkış yap / Make the pin an output
8count = 0 # Kaç kez yandığını say / Count how many times it lit
9
10while True:
11 led.on() # LED'i yak / Turn the LED on
12 count = count + 1
13 print("LED", count) # Thonny Shell'e yaz / Print to the Thonny Shell
14 time.sleep(WAIT)
15 led.off() # LED'i söndür / Turn the LED off
16 time.sleep(WAIT)
17Er zijn twee manieren om een knop te bedraden en beide zijn de moeite waard om te laten zien. Met PULL_UP gaat één pootje van de knop naar GP15 en het tegenoverliggende pootje naar GND; een weerstand in de Pico trekt de pin omhoog naar 3,3 V, door de knop in te drukken verbind je de pin met GND en leest hij 0. Alle Pico-knopprojecten in BlueGrays gebruiken deze aanpak, omdat er geen extra draad voor nodig is. Met PULL_DOWN gaat het tegenoverliggende pootje naar de pin 3V3(OUT) (pin 36) en leest de knop 1 als je hem indrukt; de logica voelt natuurlijker, maar het is makkelijk om de draad per ongeluk in VBUS (pin 40, 5 V) te steken. Welke van de vier pootjes van de knop met elkaar verbonden zijn, legden we uit in het bericht een knop aansluiten. Je kunt week 4 beginnen met de korte code hieronder en daarna doorgaan naar de standenkiezer.
1from machine import Pin
2import time
3
4led = Pin(14, Pin.OUT) # GP14 -> 220 ohm -> LED -> GND / GP14 -> 220 ohm -> LED -> GND
5button = Pin(15, Pin.IN, Pin.PULL_UP) # Buton GP15 ile GND arasında / Button between GP15 and GND
6# PULL_DOWN: Pin(15, Pin.IN, Pin.PULL_DOWN), buton GP15 ile 3V3(OUT) arasında / button between GP15 and 3V3(OUT)
7# PULL_DOWN ile koşul == 1 olur / With PULL_DOWN the condition becomes == 1
8
9while True:
10 if button.value() == 0: # PULL_UP: basınca 0 okunur / PULL_UP: reads 0 when pressed
11 led.on()
12 else:
13 led.off()
14 time.sleep_ms(10) # Döngüyü biraz yavaşlat / Slow the loop down a little
15BlueGrays gebruiken in een Pico-les
- Codegids, MicroPython-route: de Codegids in het onderdeel Leren biedt naast de Arduino C++-route een MicroPython-route van 18 kaarten: import, print, pin als uitgang, pin als ingang (PULL_UP, PULL_DOWN), time.sleep, while True, inspringen, variabelen, if / elif / else, for en range, lijsten, def en return, ADC, PWM, ticks_ms, Pin.irq, try / except en I2C. Elke kaart heeft Wat doet het?, Syntax, een voorbeeld met de tabbladen Blocks · Arduino · MicroPython, Veelgemaakte fout en een minitoets. Stel de kaarten bij het concept van de week voor om tussen de lessen te lezen; elke leerling ziet zijn eigen MicroPython-voortgang x/18 op het scherm Mijn niveau.
- Zie het in projecten: deze link onderaan elke kaart toont de projecten waarvan de code het commando gebruikt, van makkelijk naar moeilijk. Een leerling die op een kaart over een commando heeft gelezen, gaat van hieruit op zoek naar het commando in de code van een echt project.
- Vragen van de dag: de instelling "Codetaal in vragen" biedt Beide, Arduino en MicroPython. Als je les geeft met de Pico, laat leerlingen dan MicroPython kiezen; algemene vragen zonder code komen bij elke keuze mee. Er is elke dag een set van ongeveer 3 minuten, een instaptoets van 15 vragen en 6 niveaus van A1 tot C2, wat een goede dagelijkse herhaalgewoonte tussen de lessen oplevert.
- Toon als blokken: vijf van de gratis Pico-projecten (ingebouwde led, externe led, twee leds om en om, stoplicht en politieflitser) hebben naast de code een blokkenweergave. Een leerling die voor het eerst Python ziet eerst de blokken en daarna de code van hetzelfde programma laten zien, bouwt het idee "dezelfde logica, andere schrijfwijze" op; deze stap behandelden we uitgebreid in van blokken naar MicroPython. De blokken zijn om te lezen; ze kunnen in de app niet worden bewerkt en het is altijd de MicroPython-code die op het board terechtkomt.
- Code uitgelegd en Problemen oplossen: elk gratis Pico-project heeft beide. Het tabblad Code uitgelegd begint met een samenvatting Wat doet deze code?, gaat verder met een Stap voor stap-uitleg en eindigt met Als je er niet uitkomt en een opdracht Probeer het zelf. Bij de lange code van week 4 en 6 is het je grootste hulp voor tweetallen die nog niet snel kunnen lezen.
- Laten we het samen bouwen en Link kopiëren: de begeleide modus loopt door vier stappen en herinnert leerlingen bij de codestap eraan de MicroPython-interpreter in Thonny te kiezen. Link kopiëren in het onderdeel broncode geeft een link om de code op een computer te openen, zodat leerlingen de code niet vanaf de telefoon in Thonny hoeven over te typen.
Beoordeling en differentiatie
| Criterium | 1 – Beginnend | 2 – Ontwikkelend | 3 – Zelfstandig |
|---|---|---|---|
| Schakelingen bouwen | Bouwt met hulp, vergeet GND | Bouwt volgens het schema, koppelt het GP-nummer aan de code | Onderscheidt fysieke pins en GP-nummers, ziet de fout van een klasgenoot |
| Code lezen | Leest de regels, kan niet uitleggen wat ze doen | Legt in grote lijnen uit wat het programma doet | Legt elke regel uit en wat inspringen betekent |
| Veranderen en testen | Verandert een waarde, kan het effect niet uitleggen | Voorspelt het resultaat voordat hij of zij het probeert | Vindt de oorzaak in de foutmelding in de Shell als een voorspelling niet klopt |
| Koppelen aan C++ | Kan niet koppelen | Koppelt Pin, sleep en while True | Koppelt ook if, for en functies |
- Snelle groepen, analoog lezen: het plan heeft geen ADC-week; tweetallen die eerder klaar zijn, sluiten het middelste pootje van een potentiometer van 10 kΩ aan op GP26, lezen met ADC(26).read_u16() een waarde van 0 tot 65535 en gebruiken die om de snelheid van de flitser uit week 2 in te stellen. Voor een grotere uitdaging stuurt het gratis project Raspberry Pi Pico: led-kampvuur (8x8 NeoPixel-matrix + potentiometer + buzzer) een 8x8 NeoPixel-matrix aan met dezelfde potentiometer.
- Snelle groepen, combineren: de knop uit week 4 toevoegen aan de parkeersensor van week 5 om een "stille modus" te schrijven die het geluid aan- en uitzet, is de eerste echte stap naar het schrijven van eigen code.
- Langzamere groepen: deel de schakeling kant-en-klaar uit, of leg een grote uitgeprinte versie van het schakelschema op tafel. Laat ze stap voor stap werken met het tabblad Code uitgelegd en richt je erop dat ze die dag slechts één waarde veranderen; dat is op zichzelf al een mooi resultaat.
Veelvoorkomende problemen en snelle oplossingen
| Probleem | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| De computer ziet de Pico helemaal niet | Kabel die alleen oplaadt, slecht contact, USB-hub | Probeer een bekende datakabel, steek het board direct in de computer, probeer een andere USB-poort. |
| De RPI-RP2-schijf opent elke keer als je insteekt | Geen MicroPython op het board, of BOOTSEL zit vast | Kopieer het UF2-bestand naar de schijf; steek opnieuw in zonder de knop in te drukken. |
| RPI-RP2 verschijnt nooit | BOOTSEL is ingedrukt nadat het board was ingestoken | Haal de USB los, houd BOOTSEL ingedrukt terwijl je hem weer insteekt en laat dan los. |
| Thonny kan geen verbinding maken, "Device is busy" of een poortfout | Verkeerde interpreter of poort, poort geopend in een ander programma, draaiende code is bezig | Kies rechtsonder "MicroPython (Raspberry Pi Pico)", druk op Stop/Restart, sluit een tweede Thonny-venster, haal de USB los en steek hem opnieuw in. |
| No module named 'machine' | De code draait in de Python van de computer | Stel de interpreter in op MicroPython (Raspberry Pi Pico). |
| IndentationError of SyntaxError | Gemengd inspringen, ontbrekende dubbele punt | Ga naar het regelnummer in de fout; regels met while, if en def hebben een dubbele punt aan het eind nodig en 4 spaties op de regels eronder. |
| De code draait maar de led blijft donker | Led omgekeerd, geen GND, GP-nummer in de code wijkt af van de schakeling, Pin(25) op een Pico W | Lange pootje naar de weerstand (kant van GP), controleer de GND-draad, gebruik Pin("LED") voor de ingebouwde led. |
| De code werkt niet meer als je het board van de computer loskoppelt | Bestand op de computer opgeslagen, of niet main.py genoemd | Kies in Thonny opslaan > Raspberry Pi Pico en noem het main.py; de code start vanzelf zodra het board stroom krijgt. |
| main.py draait een eindeloze lus en Thonny komt er niet tussen | De code start direct bij het opstarten | Druk een paar keer op Stop of Ctrl+C in de Shell; lukt dat niet, wis dan het flashgeheugen met het officiële flash_nuke.uf2 en installeer MicroPython opnieuw (alle bestanden op het board worden verwijderd). |
Checklist vóór de les
- MicroPython is op elk board geïnstalleerd en boards en kabels zijn genummerd van 1 tot 13.
- Thonny opent op elke computer met "MicroPython (Raspberry Pi Pico)" als interpreter.
- Elke combinatie van board en kabel is getest en toont >>> in de Shell.
- Weerstanden zitten in aparte bakjes per waarde: 220 Ω, 1 kΩ, 2 kΩ.
- Het project van de week staat open in BlueGrays op de beamer; Toon als blokken is klaar voor de eerste drie weken.
- Afsluitende vragen zijn geprint en de rollen (bouwer, controleur) zijn aan de tweetallen gegeven.
- Vóór week 5 zijn de weerstanden voor de HC-SR04-spanningsdeler voor elke groep apart gelegd.
- Aan het eind van de les worden de USB-kabels losgekoppeld en de onderdelen teruggeteld in de genummerde bakjes.
Je kunt elk project dat je in deze zes weken gebruikt gratis openen in de BlueGrays-app, met het schakelschema, de onderdelenlijst, de MicroPython-code en het tabblad Code uitgelegd, waardoor je de les makkelijk vanaf de beamer kunt geven terwijl leerlingen op hun eigen telefoon meekijken. Wil je na zes weken door met Premium Pico-projecten met PWM-ledhelderheid, servo's, een OLED-scherm of een toetsenpaneel, dan kun je docentcodes uitdelen in plaats van individuele abonnementen; die koop je eenmalig en worden niet automatisch verlengd.
Veelgestelde vragen
Hoe geef je les met de Raspberry Pi Pico?
Stop in elke les één nieuw concept en orden ze als uitvoer, variabelen, functies, invoer en voorwaarden, PWM en sensoren, en dan lijsten en lussen. Laat elke les hetzelfde skelet volgen: warming-up, samen lezen, voorspelling, schakeling, de code uitvoeren, één waarde veranderen en een afsluitende vraag. Het plan van 6 weken in dit bericht is zo opgebouwd, met gratis projecten.
Hoe installeer ik MicroPython op een Raspberry Pi Pico?
Houd de BOOTSEL-knop ingedrukt terwijl je de Pico via USB op de computer aansluit; er verschijnt een schijf met de naam RPI-RP2. Kopieer het MicroPython .uf2-bestand voor jouw board naar die schijf en het board herstart. Je kunt het ook installeren met de optie "Install or update MicroPython" in de interpreterinstellingen van Thonny.
Thonny ziet mijn Raspberry Pi Pico niet. Wat moet ik doen?
Zorg er eerst voor dat je een USB-kabel gebruikt die data doorgeeft, want de computer kan het board niet zien via een kabel die alleen oplaadt. Stel daarna de interpreter in Thonny in op "MicroPython (Raspberry Pi Pico)" en druk op Stop/Restart. Als de RPI-RP2-schijf elke keer opent als je insteekt, heeft het board nog geen MicroPython, dus installeer het UF2-bestand.
Raspberry Pi Pico of Arduino voor op school?
Beide zijn goede startpunten; de keuze hangt af van de taal en de leerlingen. Als je Python geeft of snelle experimenten wilt zonder te wachten op compileren, is de Pico met MicroPython prettig. Bij jongere leerlingen, als je met blokken wilt beginnen of als je set uit 5V-modules bestaat, geeft de Arduino minder verrassingen.
Hoe laat ik code op de Pico draaien zonder computer?
Sla de code in Thonny met de optie "Raspberry Pi Pico" op het board op en noem hem main.py. De Pico voert main.py zelf uit zodra hij stroom krijgt, dus een USB-lader of powerbank is genoeg. Om de code te stoppen, verbind je het board opnieuw met Thonny en druk je op Stop.
Is er in de klas verschil tussen de Pico en de Pico W?
Elk project in dit plan werkt op beide met dezelfde pins; het enige verschil is de ingebouwde led. Op de klassieke Pico zit die aan GP25, op de Pico W aan de wifichip, dus gebruik Pin("LED"), dat op beide werkt. De Pico W heeft ook wifi en Bluetooth, maar die heb je in de eerste zes weken niet nodig.
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-politielicht (rood + blauw flitseffect)
We simuleren de lichtbalk van een politieauto met een Raspberry Pi Pico in de eenvoudigste vorm! De rode en blauwe led wisselen elkaar af (flipflop): terwijl rood brandt, is blauw uit, en elke 0,3 seconde wisselen ze, eindeloos. De code schrijft de twee stappen direct uit in één while True-lus; de snelheid stel je in met de constante WAIT_MS.

Raspberry Pi Pico-stoplicht met knop voor 4 standen (state machine)
4 stoplichtstanden met 1 knop! Elke druk schakelt de stand om: normale cyclus (rood → geel → groen), alleen rood (stop), knipperend geel (waarschuwing/nachtstand) en uit (onderhoud). Je leert de state machine (de variabele mode bepaalt welk gedrag draait) en het doorlopen van de standen met (mode + 1) % 4.

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

