Gidsen · 16 min leestijd

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.

Raspberry Pi Pico WH-board met aangesoldeerde pinheaders, een micro-USB-poort en de witte BOOTSEL-knop ernaast
Pico WH: de pinheaders zitten er al aan gesoldeerd, dus hij past direct in een breadboard. De witte knop naast de USB-poort is BOOTSEL; daarmee installeer je MicroPython.

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.

EigenschapRaspberry Pi Pico + MicroPythonArduino Uno + C++
Pinspanning3,3 V (niet 5 V-tolerant)5 V
Taal en editorMicroPython, ThonnyC++, Arduino IDE
Code uitvoerenDirect als je op Run drukt, zonder compilerenCompileren en uploaden na elke wijziging
Regel voor regel testen (REPL)Ja: >>> in de Shell van ThonnyNee
Analoge ingangen3 pins (GP26–GP28), read_u16() 0–655356 pins (A0–A5), analogRead() 0–1023
USB-poortMicro USBUSB-B (Uno R3)
Op een breadboardPico H / WH hebben headers en passen er direct inBoard zit buiten het breadboard, bedraad met jumperdraden
PrijsMeestal duidelijk goedkoper dan een UnoDuurder
De pins van de Pico werken op 3,3 V en zijn niet 5 V-tolerant. Als je een uitgang die 5 V levert op een GPIO-pin aansluit (bijvoorbeeld de ECHO-pin van een HC-SR04 die op 5 V werkt), kan de pin definitief beschadigd raken; daarom plaatsen we in week 5 een spanningsdeler van een weerstand van 1 kΩ en een van 2 kΩ op de ECHO-lijn. Laat leerlingen in de eerste les de pins VBUS (pin 40, 5 V van USB), VSYS (pin 39) en 3V3(OUT) (pin 36) zien en schrijf de regel op het bord: knoppen en sensoruitgangen gaan nooit naar VBUS. Sluit een led altijd aan via een weerstand van 220 Ω; bij 3,3 V loopt er ongeveer 6 mA door een rode led. De pins kun je samen met je leerlingen bekijken in de pinout-tool.

Vóór de eerste les: MicroPython en Thonny

  1. 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.
  2. 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).
  3. 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.
  4. 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.
  5. 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.

Om de installatie in één keer af te ronden, installeer je vóór de cursus zelf MicroPython op elk board, nummer je de boards en kabels van 1 tot 13 en zorg je dat elk tweetal elke week hetzelfde nummer krijgt. De link "Install or update MicroPython" in het interpreterventster van Thonny vindt een board in BOOTSEL-modus en laat je de juiste variant kiezen, zodat je kunt installeren zonder zelf het UF2-bestand te downloaden. Zie je bij het testen van een board >>> in de Shell, dan is die combinatie van board en kabel klaar.

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.

WeekDoelGratis BlueGrays-projectNieuw MicroPython-conceptArduino C++-equivalent
1Kennismaken met de Pico, eerste programma, digitale uitgangRaspberry 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:, inspringenpinMode(14, OUTPUT); digitalWrite(14, HIGH); delay(500); void loop()
2Variabelen, timing, twee uitgangenRaspberry 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);
3Minder herhaling: functiesRaspberry 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);
4Invoer, voorwaarden en toestandRaspberry 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()
5Sensor en geluidRaspberry Pi Pico: parkeersensor (HC-SR04 + 3 leds + buzzer)PWM(Pin(17)), freq(), duty_u16(), time_pulse_us(), def … returntone(17, 1200); pulseIn(); return
6Lijsten, for-lussen, eindprojectRaspberry Pi Pico: knoppenpiano (5 knoppen + buzzer + melodie-opnemer)NOTE_HZ = (523, 587, 659, 698, 784), for … in, vijf knoppen met dezelfde codeint notes[] = {523, 587, 659, 698, 784}; for (int i = 0; i < 5; i++)
Nederlandse blokken van het Raspberry Pi Pico-stoplichtproject: de functie all_off, GP11, GP12 en GP13 als uitgangspins, en schrijf- en wachtseconden-blokken binnen de eindeloze lus
Week 3: stoplicht. Het functieblok all_off zet alle drie de leds uit en wordt drie keer in de lus aangeroepen; de wachtblokken van 4, 1,5, 3 en 1 seconde komen één op één overeen met de sleep()-regels in de code.

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.

OnderdeelPer groepVoor de klas (12 groepen + 1 reserve)Gebruikt in week
Raspberry Pi Pico H of Pico WH (headers gesoldeerd)113Alle
Micro-USB-datakabel113Alle
Breadboard (400 of 830 gaatjes)113Alle
Jumperdraden male-male20ongeveer 260Alle
Leds van 5 mm (rood, geel, groen, blauw)4ongeveer 601–5
Weerstand van 220 Ω4ongeveer 601–5
Drukknop (4 pootjes)5ongeveer 704, 6
Passieve buzzer1135, 6
HC-SR04 ultrasone afstandssensor1135
Weerstand van 1 kΩ en 2 kΩ (ECHO-deler)1 + 113 + 135
Computer met Thonny112Alle
Potentiometer van 10 kΩ (optioneel, voor ADC)113Snelle groepen
Kies bij het kopen van boards de Pico H, de Pico WH of een versie waarvan de headers al zijn gesoldeerd. Een Pico zonder headers past niet in een breadboard en 40 pins solderen op 13 boards kost je een weekend; als je solderen bewust onderdeel van de cursus wilt maken, zie hoe je soldeert. Zorg dat de kabels datakabels zijn: goedkope micro-USB-kabels die alleen opladen geven het board stroom, maar de computer ziet de Pico nooit, en dat is de grootste tijdrover van de eerste les. Bewaar weerstanden in aparte bakjes per waarde; je kunt de kleurbanden samen met je leerlingen controleren met de tool weerstandskleurcode en de juiste waarde voor een led met de led-weerstandscalculator.

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.

TijdFaseWat er gebeurt
0–5 minWarming-upVraag: 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 minEerste commando in de REPLThonny 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 minHet project samen lezenOpen 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 minUitvoerenPlak 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 minSchakeling met externe ledUSB 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 minEén waarde veranderenVerander 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 minAfsluitende vraagEé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.

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

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

MicroPython
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)
17

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

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

BlueGrays 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

Criterium1 – Beginnend2 – Ontwikkelend3 – Zelfstandig
Schakelingen bouwenBouwt met hulp, vergeet GNDBouwt volgens het schema, koppelt het GP-nummer aan de codeOnderscheidt fysieke pins en GP-nummers, ziet de fout van een klasgenoot
Code lezenLeest de regels, kan niet uitleggen wat ze doenLegt in grote lijnen uit wat het programma doetLegt elke regel uit en wat inspringen betekent
Veranderen en testenVerandert een waarde, kan het effect niet uitleggenVoorspelt het resultaat voordat hij of zij het probeertVindt de oorzaak in de foutmelding in de Shell als een voorspelling niet klopt
Koppelen aan C++Kan niet koppelenKoppelt Pin, sleep en while TrueKoppelt 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

ProbleemWaarschijnlijke oorzaakOplossing
De computer ziet de Pico helemaal nietKabel die alleen oplaadt, slecht contact, USB-hubProbeer een bekende datakabel, steek het board direct in de computer, probeer een andere USB-poort.
De RPI-RP2-schijf opent elke keer als je insteektGeen MicroPython op het board, of BOOTSEL zit vastKopieer het UF2-bestand naar de schijf; steek opnieuw in zonder de knop in te drukken.
RPI-RP2 verschijnt nooitBOOTSEL is ingedrukt nadat het board was ingestokenHaal 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 poortfoutVerkeerde interpreter of poort, poort geopend in een ander programma, draaiende code is bezigKies 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 computerStel de interpreter in op MicroPython (Raspberry Pi Pico).
IndentationError of SyntaxErrorGemengd inspringen, ontbrekende dubbele puntGa 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 donkerLed omgekeerd, geen GND, GP-nummer in de code wijkt af van de schakeling, Pin(25) op een Pico WLange 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 loskoppeltBestand op de computer opgeslagen, of niet main.py genoemdKies 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 tussenDe code start direct bij het opstartenDruk 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.

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-politielicht (rood + blauw flitseffect)
PI-5Beginner

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.

4.7(3)
10
Raspberry Pi Pico-stoplicht met knop voor 4 standen (state machine)
PI-12Gemiddeld

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.

5.0(1)
16
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 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