Lesplan programmeren met blokken: 8 weken Arduino-robotica
Lesplan programmeren met blokken voor docenten: 8 weken Arduino-lessen van 40 minuten met gratis blokprojecten, een materiaallijst voor 24 leerlingen, een voorbeeldles en een beoordelingsrubric.
Robotica-programmeren betekent programma's schrijven waarmee een board zijn omgeving waarneemt, een beslissing neemt en iets laat gebeuren: een knop of lichtsensor neemt waar, de Arduino beslist en een led, buzzer of motor reageert. De makkelijkste manier om die cyclus in de klas te leren is beginnen met programmeren met blokken en daarna overstappen op de echte code van hetzelfde programma, zodra leerlingen de logica snappen. Dit artikel is een kant-en-klaar lesplan voor programmeren met blokken voor docenten, roboticaclubs en ouders die thuis een workshop geven: 8 weken, elke week één les van 40 minuten, telkens rond een gratis blokproject in BlueGrays.
Elke week van het plan heeft een doel, een gratis BlueGrays-project, het nieuwe blok dat leerlingen die week leren kennen en het equivalent in echte code. Daarna krijg je een materiaallijst voor een klas van 24, een voorbeeldles per minuut, een beoordelingsrubric, differentiatie-ideeën voor snelle en langzamere groepen, een optie zonder hardware met simulators en veiligheidsnotities. Het plan is opgebouwd rond de Arduino Uno, met een optionele week over de Raspberry Pi Pico en MicroPython.
Wat is robotica-programmeren en waarom beginnen met blokken?
Bij robotica-cursussen denkt iedereen meteen aan robotauto's, maar elke robot draait om dezelfde drie taken: waarnemen, beslissen en handelen. Een knop uitlezen is waarnemen, vragen "is de knop ingedrukt?" is beslissen, en een led laten branden of een buzzer laten klinken is handelen. Als een leerling deze drie stappen begrijpt met een led en een knop, is dezelfde logica overzetten op motoren en een afstandssensor vooral een kwestie van onderdelen verwisselen. Daarom begint dit plan met leds en knoppen in plaats van motoren, en komt het in de laatste week bij de "ogen" van de robot: de HC-SR04-afstandssensor.
Waarom beginnen met blokken? Voor kinderen van 10 tot 14 jaar zijn puntkomma's, accolades en hoofdletters de grootste vijand van de eerste lessen; leerlingen denken dan na over waarom de code niet compileert in plaats van over wat het programma doet. Blokken halen die fouten weg, zodat de aandacht direct naar de logica gaat. Blijven hangen in blokken is niet het doel: in de echte wereld wordt de Arduino geprogrammeerd in C++ en de Pico in MicroPython. De blokken in BlueGrays zijn precies voor deze brug gemaakt; elk blok komt één-op-één overeen met een regel van de echte code die op het board komt. Leerlingen lezen eerst de blokken, bekijken daarna de code van hetzelfde programma en koppelen elk blok aan zijn regel. Alle blokprojecten en hoe ze werken zie je op de pagina over programmeren met blokken.
Het lesplan van 8 weken voor programmeren met blokken
Elke les is gepland op 40 minuten met groepjes van 2 of 3. Elk project in de tabel is in BlueGrays volledig gratis, blokken en code inbegrepen, dus leerlingen hebben geen Premium nodig. De volgorde is bewust gekozen: eerst uitvoer (led), dan timing, variabelen en herhaling, dan invoer (knop) en voorwaarden, een toestand onthouden, een analoge sensor, arrays en lussen, en tot slot geluid en afstand. Elke week voegt precies één nieuw idee toe aan het vorige.
| Week | Doel | Gratis BlueGrays-project | Nieuw blok / concept | In echte code |
|---|---|---|---|---|
| 1 | Wat een programma is, digitale uitvoer | Led knipperen | setup (eenmalig uitgevoerd), loop voor altijd, zet pin … als OUTPUT, schrijf HIGH / LOW naar pin …, wacht … ms | setup(), loop(), pinMode(), digitalWrite(), delay() |
| 2 | Volgorde van commando's en timing | Twee leds om en om laten knipperen, Stoplicht | Dezelfde blokken achter elkaar zetten op verschillende pins, de wachttijden aanpassen | Volgorde van regels; 2000 ms = 2 s |
| 3 | Variabelen en een vast aantal herhalingen | Led-politielichten | globale variabelen (bovenaan), declareer geheel getal (int) delayTime = 60, het blok herhaal 3 keer | int delayTime = 60; for (int i = 0; i < 3; i++) |
| 4 | Invoer en voorwaarden | Led bedienen met een drukknop (Push) | zet pin … als INPUT, lees pin …, het blok als / anders, = vergelijking | pinMode(13, INPUT), digitalRead(), if / else, == |
| 5 | Een toestand onthouden (toggle) | Led schakelen met een knop (aan/uit) | zet … op …, ≠ vergelijking, niet, wacht 50 ms | ledState = !ledState; !=; contactdender van de knop |
| 6 | Analoge sensor en drempelwaarde | Lichtsterkte meten met een LDR, Nachtlampje met LDR | Blok analoog lezen (A0), serial-start- en serial-printblokken, < vergelijking | analogRead(A0) 0–1023, Serial.begin(9600), Serial.println(), if (value < 50) |
| 7 | Arrays en lussen | Looplicht, Looplicht met instelbare snelheid | Arrayblok (2 3 4 5 6 7), telllus met i van 0 tot 5, item i van ledPins | int ledPins[] = {2, 3, 4, 5, 6, 7}; for (int i = 0; i < 6; i++) |
| 8 | Geluid en afstand: de zintuigen van de robot | Een buzzer gebruiken, HC-SR04-afstandsmeting (Serial-weergave) | Toon- en stoptoonblokken, wachten in microseconden, pulslengteblok en | tone(), noTone(), delayMicroseconds(10), pulseIn(), && |
| Optioneel | Pico en MicroPython | Pico externe led (GP14) | Pinblok voor GP14 als uitgang, blokken led aan / uit, wacht 0,5 seconden | Pin(14, Pin.OUT), led.on(), time.sleep(0.5), while True: |

Maak het tijdens het plan een regel dat leerlingen aan het eind van elke les één waarde veranderen. Als in week 1 de led langzamer gaat knipperen doordat de wachttijd van 100 ms in Led knipperen 1000 ms wordt, krijgen ze al in de allereerste les het gevoel dat zij het programma bepalen. In week 3 laat het verhogen van de variabele delayTime in Led-politielichten van 60 naar 200 zien dat één getal zes blokken tegelijk beïnvloedt; de kortste manier om uit te leggen waarom variabelen bestaan. In week 6 leert het afstellen van de drempelwaarde van 50 in Nachtlampje met LDR op het licht in jouw klaslokaal dat sensorwaarden van de omgeving afhangen. Geef in week 7 elke groep een potmeter van 10 kΩ voor Looplicht met instelbare snelheid; de snelheid van de leds met de hand veranderen wordt meestal het favoriete moment van de week.
Materiaallijst voor een klas van 24
Verdeel 24 leerlingen in groepjes van 3 en je krijgt 8 groepen; 9 kits voorbereiden, waarvan één reserve, is genoeg. Werk je liever in tweetallen, schaal de aantallen dan op naar 12 groepen. Niets hoeft gesoldeerd te worden; elk onderdeel past in een breadboard. In plaats van onderdelen los te kopen kun je de inhoud van een kant-en-klare starterkit met deze lijst vergelijken; wat de gangbare kits bevatten behandelen we in de gids Arduino-starterkit.
| Onderdeel | Per groep | Voor de klas (8 groepen + 1 reserve) | Gebruikt in week |
|---|---|---|---|
| Arduino Uno of compatibel board | 1 | 9 | Alle |
| USB-kabel (USB A-B voor de Uno) | 1 | 9 | Alle |
| Breadboard (400 of 830 gaatjes) | 1 | 9 | Alle |
| Jumperdraden male-male | 20 | ongeveer 200 | Alle |
| Leds van 5 mm (gemengd rood, geel, groen, blauw) | 8 | ongeveer 80 | 1–7 |
| Weerstanden van 220 Ω | 8 | ongeveer 80 | 1–7 |
| Weerstanden van 10 kΩ | 2 | ongeveer 25 | 4–6 |
| Drukknoppen (4 pins) | 2 | ongeveer 20 | 4–5 |
| LDR (lichtsensor) | 1 | 10 | 6 |
| Buzzer (passief, zodat de toonhoogte kan veranderen) | 1 | 10 | 8 |
| HC-SR04 ultrasone afstandssensor | 1 | 10 | 8 |
| Potmeter van 10 kΩ (optioneel) | 1 | 10 | 7 |
| Raspberry Pi Pico + micro-USB-kabel (optioneel) | 1 | een paar | Pico-week |
Voorbeeldles: week 5, een led schakelen met een knop
De onderstaande opzet is voor een les van 40 minuten, en je kunt elke week hetzelfde skelet hergebruiken: warming-up, samen de blokken lezen, voorspelling, schakeling, echte code, één waarde veranderen, afsluitende vraag. Het voorbeeld gebruikt het project van week 5, Led schakelen met een knop (aan/uit), omdat het idee dat "een programma iets kan onthouden" een van de keerpunten van robotica-programmeren is.
| Tijd | Fase | Wat er gebeurt |
|---|---|---|
| 0–5 min | Warming-up | Vraag: je drukt één keer op een lichtschakelaar en de lamp gaat aan, je drukt nog een keer en hij gaat uit. Hoe onthoudt de schakelaar dat? Schrijf een paar antwoorden op het bord. |
| 5–12 min | Samen de blokken lezen | Open het project op de beamer met Weergeven als blokken aan. Lees de blokken hardop van boven naar beneden en bespreek wat de variabelen ledState en lastButton bevatten. |
| 12–15 min | Voorspelling | Elke groep schrijft op: wat doet de led als ik de knop ingedrukt houd? Wat zou er veranderen zonder het blok wacht 50 ms? |
| 15–25 min | De schakeling bouwen | Knop naar D13 en via 10 kΩ naar GND (pull-down), led via 220 Ω naar D7. Rollen: bouwer, controleur, lezer. |
| 25–32 min | De echte code uploaden | Zet de schakelaar uit, kopieer de code naar de Arduino IDE en upload hem naar het board. Test de voorspellingen. |
| 32–37 min | Eén waarde veranderen | Verander delay(50) eerst in 0 en daarna in 300 en kijk hoe de led zich gedraagt bij snelle indrukken. Groepen die dat willen kunnen de ledpin veranderen, zowel in de code als in de schakeling. |
| 37–40 min | Afsluitende vraag | Eén vraag, op papier: wat doet de regel ledState = !ledState en welk blok hoort erbij? |

1int ledState = 0; // LED durumu: 0 = kapalı, 1 = açık / LED state: 0 = off, 1 = on
2int lastButton = 0; // Önceki buton okuması / Previous button reading
3
4void setup() {
5 pinMode(13, INPUT); // Buton girişi (harici pull-down) / Button input (external pull-down)
6 pinMode(7, OUTPUT); // LED çıkışı / LED output
7}
8
9void loop() {
10 int button = digitalRead(13); // Butonu oku / Read the button
11 if (button != lastButton) { // Buton durumu değişti / Button state changed
12 if (button == 1) { // Yalnız basış anında (LOW -> HIGH) / Only at the press (LOW -> HIGH)
13 ledState = !ledState; // Durumu tersine çevir / Flip the state
14 digitalWrite(7, ledState);
15 }
16 delay(50); // Sıçramayı atlamak için kısa bekleme / Short wait to skip the bounce
17 lastButton = button; // Bu okumayı sakla / Store this reading
18 }
19}
20Zet je de blokken en de code naast elkaar, dan is de koppeling heel duidelijk: de twee blokken "declareer geheel getal (int)" binnen "globale variabelen (bovenaan)" zijn de eerste twee regels code, "setup (eenmalig uitgevoerd)" wordt setup() en "loop voor altijd" wordt loop(). Het blok "zet button op lees pin 13" is de regel int button = digitalRead(13), de vergelijking "≠" is != en "niet ledState" is !ledState. Tijdens de voorspelfase zeggen de meeste groepen "als ik de knop ingedrukt houd, gaat de led knipperen"; als ze het uitproberen, zien ze dat de led maar één keer verandert, omdat de buitenste "als" alleen draait wanneer de knoptoestand verandert. Het moment waarop een verkeerde voorspelling wordt gecorrigeerd is de leerzaamste minuut van de les. Als delay(50) 0 wordt, merken ze dat sommige indrukken de led twee keer omdraaien, zodat het lijkt alsof er niets gebeurde; een perfecte aanleiding om contactdender uit te leggen. Voor groepen die willen weten waarom de knop via 10 kΩ naar GND gaat, is er de gids over het aansluiten van een knop.
BlueGrays gebruiken in de klas
- Het project openen: Leerlingen openen het project van de week op hun eigen telefoon of tablet. De blokbadge in de projectlijst markeert blokprojecten, en met het filter zie je alleen die. Elk project heeft een onderdelenlijst en een schakelschema.
- Weergeven als blokken: Als je deze schakelaar in het codegedeelte aanzet, worden de code vervangen door de blokken van hetzelfde programma. Tik op de afbeelding en hij opent op volledig scherm, ideaal om samen te lezen op de beamer. De blokken verschijnen in de taal van de app.
- Blokken uitgelegd: Dit tabblad loopt het programma stap voor stap door; elke stap toont alleen de blokken van die stap en wat ze doen. Het werkt als een onderwijsassistent voor groepen die meer tijd nodig hebben.
- Overstappen op de echte code: Zet de schakelaar uit en de code van hetzelfde programma verschijnt. Leerlingen kopiëren hem naar de Arduino IDE (Thonny voor de Pico) en uploaden hem naar het board.
- Codegids: Hier staan voorbeelden voor commando's als digitalWrite, if/else en for, en elk voorbeeld is er ook als blokken. Leerlingen leren hier eerst te kijken voordat ze het jou vragen als ze een commando vergeten zijn.
- Vragen van de dag: Vijf vragen per dag, gelaagd van A1 tot C2, met een wekelijkse ranglijst en badges. Je kunt het aanraden voor een paar minuten herhaling per dag tussen de lessen door.
Geen hardware? Lesgeven met een simulator
Als de kits nog niet binnen zijn of je op afstand lesgeeft, zijn simulators in de browser zoals Tinkercad Circuits en Wokwi een goed alternatief. Beide bevatten de Arduino Uno, breadboard, leds, weerstanden en knoppen, plus een breed scala aan sensoren; je bouwt de schakeling op het scherm en laat hem draaien door de echte code van het project te plakken. De werkwijze blijft gelijk: leerlingen lezen de blokken in BlueGrays, plakken de code in de simulator, veranderen een waarde en bekijken het resultaat. Tinkercad heeft ook een eigen blokeditor, dus sommige docenten besteden de eerste weken er helemaal aan. Toch doet een echte led zien branden en draden in een breadboard steken wonderen voor de motivatie, dus het werkt beter om de simulator vóór de hardware te zetten in plaats van ervoor in de plaats. Voor de installatie en een eerste schakeling zie je de gidsen over Arduino-simulatie in Tinkercad en Wokwi-simulatie.
Beoordeling: een rubric voor lessen programmeren met blokken
Bij robotica-lessen telt het proces net zo zwaar als het resultaat: de groep die de led liet branden en de groep die uitzocht waarom hij niet brandde, hebben misschien wel hetzelfde geleerd. De onderstaande rubric is makkelijker te gebruiken als je per les op één criterium let; aan het eind van de 8 weken is het genoeg als elke leerling minstens één keer is geobserveerd op elk van de zes criteria. De afsluitende vragen voeden de tabel ook.
| Criterium | 1 – Beginnend | 2 – Zich ontwikkelend | 3 – Zelfstandig |
|---|---|---|---|
| De schakeling bouwen | Bouwt met hulp, maakt vaak bedradingsfouten | Bouwt volgens het schema, vindt zelf een of twee fouten | Heeft het schema nauwelijks nodig, ziet een fout van een klasgenoot |
| Blokken lezen | Leest blokkennamen voor, kan de volgorde niet uitleggen | Legt in grote lijnen uit wat het programma doet | Legt elk blok uit en waarom de volgorde ertoe doet |
| Voorspellen en testen | Voorspelt en test niet | Voorspelt en noteert het resultaat | Vindt de reden als een voorspelling niet klopt |
| Blokken aan code koppelen | Kan een blok niet aan een regel code koppelen | Vindt de blokken voor pin, schrijven en wachten terug in de code | Koppelt ook de regels met if, for en variabelen |
| Waarden veranderen | Verandert een waarde, kan het effect niet uitleggen | Verandert hem en legt het effect uit | Plant de wijziging, vindt fouten aan de hand van de compilermelding |
| Samenwerking | Laat zijn of haar rol vaak vallen | Voert de eigen rol uit | Wisselt van rol, helpt andere groepen |
Differentiatie voor snelle en langzamere groepen
- Snelle groepen, extra opdracht: voeg een vierde fase toe aan de code van Stoplicht (bijvoorbeeld rood en geel tegelijk) of bereken de timing opnieuw voor een echt kruispunt. Ze passen de code zelf aan in de Arduino IDE en gebruiken de blokken als naslag.
- Snelle groepen, combineren: probeer in week 8 HC-SR04-afstandsmeting (Serial-weergave) en Een buzzer gebruiken samen te voegen tot één programma dat de buzzer laat klinken als de afstand onder 20 cm komt, een eenvoudige parkeersensor. Dit is de eerste echte stap van blokken lezen naar je eigen code schrijven.
- Snelle groepen, van platform wisselen: groepen met een Pico openen het project Pico externe led en vergelijken de MicroPython-versie met de C++-code uit week 1.
- Langzamere groepen, kant-en-klare schakeling: deel de schakeling al gebouwd uit, of leg een grote afdruk van het schema op tafel. Deze groepen besteden hun tijd aan het lezen van de blokken en het voorspellen.
- Langzamere groepen, stap voor stap: laat ze het programma doorlopen met het tabblad Blokken uitgelegd en aan het eind van elke stap in één zin zeggen wat er gebeurt. Eén waarde veranderen is een prima doel voor die dag.
- Gemengde koppeling: zorg dat elke groep minstens één "lezer" heeft; een leerling die snel is met bedraden maar traag met lezen koppelen aan iemand die het omgekeerde is, brengt beiden vooruit.
Van blokken naar tekst: wanneer en hoe
Er is geen vaste week voor de overstap; het juiste moment is wanneer een leerling naar de blokken kan kijken en kan zeggen wat het programma gaat doen voordat hij het uitvoert. In dit plan bereiken de meeste klassen dat punt in week 4 of 5. Toch begint kennismaken met code op dag één: omdat in elke les de echte code op het board komt, zien leerlingen de regels setup(), loop() en digitalWrite() al vanaf week 1. De overstap verschuift langzaam van "kijk naar de blokken, upload de code" naar "lees de code, check zo nodig de blokken". De onderstaande volgorde maakt die verschuiving makkelijker:
- Zet de blokken en de code naast elkaar en zoek samen de regel die bij elk blok hoort (week 1–3).
- Verberg de blokken, lees alleen de code en voorspel wat het programma gaat doen; controleer daarna met Weergeven als blokken (week 4–5).
- Verander waarden alleen in de code: wachttijd, pinnummer, drempelwaarde. Krijg je een compilerfout, lees dan de eerste regel (week 5–6).
- Schrijf een nieuwe regel code: voeg bijvoorbeeld nog een led toe aan de array van het Looplicht en verhoog de lusgrens van 6 naar 7 (week 7).
- Combineer twee projecten tot een klein programma van jezelf; kom je er niet uit, kijk dan naar de voorbeelden en blokken in de Codegids (week 8 en verder).
Veiligheidstips
De serie Van blokken naar code in een overzicht
- Deel 1: Wat programmeren met blokken is en hoe een blokprogramma echte code wordt.
- Deel 2: Een led laten knipperen met blokken: het eerste programma, blokken en C++ naast elkaar.
- Deel 3: Het als-blok en een knop: voorwaarden en hun if/else-equivalent.
- Deel 4: Lussen en variabelen: loop voor altijd en loop(), tellen en for, arrays, tellers.
- Deel 5: Sensoren uitlezen met blokken en MicroPython: seriële poort, LDR, HC-SR04 en de Pico.
- Deel 6: Dit artikel, dat alles wat je geleerd hebt omzet in een lesplan van 8 weken voor programmeren met blokken in de klas.
Daarmee is de serie afgerond; wil je de logica nog een keer opfrissen voordat je in de klas begint, ga dan terug naar het begin met wat programmeren met blokken is. Alle projecten uit het plan kun je in de BlueGrays-app bekijken met schakelschema, onderdelenlijst en code; schakel met Weergeven als blokken over op de blokversie van hetzelfde programma, of met Blokken uitgelegd op de uitleg stap voor stap, en geef de les gemakkelijk vanaf de beamer.
Veelgestelde vragen
Wat is robotica-programmeren?
Robotica-programmeren betekent programma's schrijven waarmee een board zijn omgeving met sensoren waarneemt, beslissingen neemt en reageert met onderdelen zoals leds, buzzers of motoren. Scholen beginnen meestal met boards als de Arduino en programmeren met blokken, en stappen daarna over op tekstgebaseerde talen zoals C++ of MicroPython.
Op welke leeftijd kunnen kinderen beginnen met robotica-programmeren?
Kinderen vanaf 9 à 10 jaar die vlot lezen kunnen samen met een volwassene beginnen. Op die leeftijd zijn programmeren met blokken en breadboardschakelingen zonder solderen het beste startpunt. Rond 12 jaar zijn de meeste leerlingen klaar om echte code te lezen.
Hoe schrijf ik een lesplan voor programmeren met blokken?
Geef elke les één nieuw idee en zet ze in de volgorde uitvoer, timing, variabelen, invoer, voorwaarden, sensoren en lussen. Houd elke les hetzelfde skelet aan: warming-up, samen de blokken lezen, voorspelling, schakeling, echte code, één waarde veranderen en een afsluitende vraag. Het plan van 8 weken in dit artikel volgt die structuur.
Welke materialen heb ik nodig voor een Arduino-klas?
Per groep volstaan een Arduino Uno of compatibel board, een USB-kabel, een breadboard, jumperdraden, leds, weerstanden van 220 Ω en 10 kΩ, een knop, een LDR, een buzzer en een HC-SR04-afstandssensor. Bereid voor een klas van 24 in groepjes van 3 8 kits plus een reserve voor.
Kun je robotica-programmeren leren zonder Arduino?
Ja, simulators in de browser zoals Tinkercad Circuits en Wokwi laten je de schakeling op het scherm bouwen en de code uitvoeren. Een echte led zien branden geeft de motivatie wel een flinke boost, dus de simulator werkt het best als voorbereiding op de hardware.
Wanneer moeten leerlingen van programmeren met blokken overstappen op Arduino-code?
Zodra een leerling naar de blokken kan kijken en kan zeggen wat het programma gaat doen, is het zover; in dit plan bereiken de meeste klassen dat punt in week 4 of 5. Lees eerst de blokken en de code naast elkaar, verander daarna waarden alleen in de code en schrijf tot slot nieuwe regels.
Projecten om hierna te bouwen
Alle projecten bekijken
LED laten knipperen
De allereerste hallo van de elektronica: één LED aan- en uitzetten. De Arduino zet de LED met korte tussenpozen aan en uit, zodat het licht snel knippert.

Verkeerslicht
Een kleine kopie van het verkeerslicht dat je elke dag op straat ziet. Rood brandt twee seconden, geel knippert even, groen brandt twee seconden en daarna gaat het via geel weer naar rood, steeds…

LED-politielichten
Net als de lichten van een politieauto: de rode LED knippert drie keer snel achter elkaar, daarna knippert de blauwe LED drie keer, en dit patroon herhaalt zich zonder pauze.

LED aansturen met een drukknop (Push)
Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

LED schakelen met een knop (aan/uit)
Druk één keer op de knop en het licht gaat aan, druk nog een keer en het gaat uit, net als de lichtschakelaar in je kamer. De Arduino merkt elke druk op en zet de led in de tegenovergestelde toestand.

Nachtlampje met LDR
Een klein nachtlampje dat vanzelf aangaat als het donker wordt en uitgaat als het ochtend is.

LED-looplicht
Lichten die na elkaar aangaan, alsof ze rennen. De Arduino laat zes LED's een voor een branden; elke LED licht even op en gaat uit, zodat het licht van begin tot eind loopt en dan opnieuw begint.

Afstand meten met HC-SR04 (Serial-weergave)
De HC-SR04-sensor werkt net als een vleermuis die in het donker zijn weg vindt: hij stuurt een geluid uit dat je niet kunt horen, luistert naar de echo en meet hoe ver het object voor hem staat.
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

