Gidsen · 13 min leestijd

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.

Dit artikel is deel 6, het laatste deel, van de serie Van blokken naar code. In het vorige deel behandelden we sensoren uitlezen met blokken en overstappen op MicroPython op de Pico; wil je de serie vanaf het begin volgen, ga dan terug naar wat programmeren met blokken is.

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.

WeekDoelGratis BlueGrays-projectNieuw blok / conceptIn echte code
1Wat een programma is, digitale uitvoerLed knipperensetup (eenmalig uitgevoerd), loop voor altijd, zet pin … als OUTPUT, schrijf HIGH / LOW naar pin …, wacht … mssetup(), loop(), pinMode(), digitalWrite(), delay()
2Volgorde van commando's en timingTwee leds om en om laten knipperen, StoplichtDezelfde blokken achter elkaar zetten op verschillende pins, de wachttijden aanpassenVolgorde van regels; 2000 ms = 2 s
3Variabelen en een vast aantal herhalingenLed-politielichtenglobale variabelen (bovenaan), declareer geheel getal (int) delayTime = 60, het blok herhaal 3 keerint delayTime = 60; for (int i = 0; i < 3; i++)
4Invoer en voorwaardenLed bedienen met een drukknop (Push)zet pin … als INPUT, lees pin …, het blok als / anders, = vergelijkingpinMode(13, INPUT), digitalRead(), if / else, ==
5Een toestand onthouden (toggle)Led schakelen met een knop (aan/uit)zet … op …, ≠ vergelijking, niet, wacht 50 msledState = !ledState; !=; contactdender van de knop
6Analoge sensor en drempelwaardeLichtsterkte meten met een LDR, Nachtlampje met LDRBlok analoog lezen (A0), serial-start- en serial-printblokken, < vergelijkinganalogRead(A0) 0–1023, Serial.begin(9600), Serial.println(), if (value < 50)
7Arrays en lussenLooplicht, Looplicht met instelbare snelheidArrayblok (2 3 4 5 6 7), telllus met i van 0 tot 5, item i van ledPinsint ledPins[] = {2, 3, 4, 5, 6, 7}; for (int i = 0; i < 6; i++)
8Geluid en afstand: de zintuigen van de robotEen buzzer gebruiken, HC-SR04-afstandsmeting (Serial-weergave)Toon- en stoptoonblokken, wachten in microseconden, pulslengteblok entone(), noTone(), delayMicroseconds(10), pulseIn(), &&
OptioneelPico en MicroPythonPico externe led (GP14)Pinblok voor GP14 als uitgang, blokken led aan / uit, wacht 0,5 secondenPin(14, Pin.OUT), led.on(), time.sleep(0.5), while True:
Nederlandse blokken van het project Stoplicht: pins 2, 3 en 4 ingesteld als uitgangen in setup, blokken schrijf HIGH/LOW en wacht binnen loop voor altijd
Week 2: Stoplicht. Leerlingen lezen de tijden 2000 ms rood, 300 ms geel en 2000 ms groen af uit de blokken en koppelen ze aan de delay()-regels in de code.

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.

Heb je in je klas een paar Raspberry Pi Pico's, voeg dan na week 8 nog een les toe: het project Raspberry Pi Pico externe led is de MicroPython-versie van het led-knipperproject uit week 1. De blokken laten dezelfde logica weer zien (een blok led aan, een blok wacht 0,5 seconden), maar de code is nu Python: Pin(14, Pin.OUT), led.on() en time.sleep(0.5). Je plakt de code in Thonny en voert hem uit. Hetzelfde programma in twee talen zien is de duidelijkste manier om leerlingen te laten zien dat de logica gelijk blijft terwijl de schrijfwijze verandert.

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.

OnderdeelPer groepVoor de klas (8 groepen + 1 reserve)Gebruikt in week
Arduino Uno of compatibel board19Alle
USB-kabel (USB A-B voor de Uno)19Alle
Breadboard (400 of 830 gaatjes)19Alle
Jumperdraden male-male20ongeveer 200Alle
Leds van 5 mm (gemengd rood, geel, groen, blauw)8ongeveer 801–7
Weerstanden van 220 Ω8ongeveer 801–7
Weerstanden van 10 kΩ2ongeveer 254–6
Drukknoppen (4 pins)2ongeveer 204–5
LDR (lichtsensor)1106
Buzzer (passief, zodat de toonhoogte kan veranderen)1108
HC-SR04 ultrasone afstandssensor1108
Potmeter van 10 kΩ (optioneel)1107
Raspberry Pi Pico + micro-USB-kabel (optioneel)1een paarPico-week
Doe de weerstanden vóór de les in aparte doosjes en schrijf de waarde op elk deksel: 220 Ω (rood-rood-bruin) voor de leds en 10 kΩ (bruin-zwart-oranje) voor de knop en de LDR. Raken die twee door elkaar, dan brandt de led heel zwak of werkt de knop helemaal niet, en dat uitzoeken kost een halve les. Je kunt de kleurbanden samen met de leerlingen controleren met de weerstandskleurcode-calculator en de juiste waarde voor een led met de ledweerstandscalculator.

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.

TijdFaseWat er gebeurt
0–5 minWarming-upVraag: 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 minSamen de blokken lezenOpen 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 minVoorspellingElke 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 minDe schakeling bouwenKnop naar D13 en via 10 kΩ naar GND (pull-down), led via 220 Ω naar D7. Rollen: bouwer, controleur, lezer.
25–32 minDe echte code uploadenZet de schakelaar uit, kopieer de code naar de Arduino IDE en upload hem naar het board. Test de voorspellingen.
32–37 minEén waarde veranderenVerander 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 minAfsluitende vraagEén vraag, op papier: wat doet de regel ledState = !ledState en welk blok hoort erbij?
Nederlandse blokken van het project Led schakelen met een knop: globale variabelen, setup, loop voor altijd, geneste als-blokken, niet en wacht 50 ms
Wat de beamer toont in de voorbeeldles: de buitenste als controleert of de knop is veranderd, de binnenste als controleert of hij is ingedrukt en het blok "niet ledState" draait de ledtoestand om.
C++ (Arduino IDE)
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}
20

Zet 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.
Maak vanaf het begin duidelijk wat je kunt verwachten: in BlueGrays zijn blokken bedoeld om programma's te lezen en te begrijpen. Leerlingen kunnen in de app niet zelf blokken rangschikken om een programma te schrijven, en blokken worden niet rechtstreeks naar het board geüpload; het board krijgt altijd de echte code van het project. Plan je een activiteit waarin leerlingen helemaal zelf een blokprogramma bouwen, gebruik dan een desktoptool waarin je blokken sleept om programma's te schrijven; die aanpak behandelen we in de gids mBlock met Arduino. De twee methoden vullen elkaar goed aan.

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.

Criterium1 – Beginnend2 – Zich ontwikkelend3 – Zelfstandig
De schakeling bouwenBouwt met hulp, maakt vaak bedradingsfoutenBouwt volgens het schema, vindt zelf een of twee foutenHeeft het schema nauwelijks nodig, ziet een fout van een klasgenoot
Blokken lezenLeest blokkennamen voor, kan de volgorde niet uitleggenLegt in grote lijnen uit wat het programma doetLegt elk blok uit en waarom de volgorde ertoe doet
Voorspellen en testenVoorspelt en test nietVoorspelt en noteert het resultaatVindt de reden als een voorspelling niet klopt
Blokken aan code koppelenKan een blok niet aan een regel code koppelenVindt de blokken voor pin, schrijven en wachten terug in de codeKoppelt ook de regels met if, for en variabelen
Waarden veranderenVerandert een waarde, kan het effect niet uitleggenVerandert hem en legt het effect uitPlant de wijziging, vindt fouten aan de hand van de compilermelding
SamenwerkingLaat zijn of haar rol vaak vallenVoert de eigen rol uitWisselt 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:

  1. Zet de blokken en de code naast elkaar en zoek samen de regel die bij elk blok hoort (week 1–3).
  2. Verberg de blokken, lees alleen de code en voorspel wat het programma gaat doen; controleer daarna met Weergeven als blokken (week 4–5).
  3. Verander waarden alleen in de code: wachttijd, pinnummer, drempelwaarde. Krijg je een compilerfout, lees dan de eerste regel (week 5–6).
  4. 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).
  5. 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

Elke schakeling in dit plan werkt op 5 V via USB; er is geen extra batterij of adapter nodig, dus gebruik niets wat op de netspanning wordt aangesloten. Haal de USB-kabel los voordat je een schakeling verandert. De 5V-pin rechtstreeks met GND verbinden veroorzaakt kortsluiting: het board wordt heet en de computer kan de USB-poort uitschakelen. Sluit een led altijd aan via een weerstand van 220 Ω en verbind pins nooit rechtstreeks met elkaar. Wordt een onderdeel heet of ruik je iets branden, trek dan meteen de USB-kabel eruit. Scherpe pootjes van componenten en uiteinden van jumperdraden vragen aandacht bij jongere kinderen; tel aan het eind van de les de onderdelen terug in hun doosjes.

De serie Van blokken naar code in een overzicht

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.

Alle projecten bekijken
LED laten knipperen
AR-1Beginner

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.

4.6(198)
1243
Verkeerslicht
AR-3Beginner

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…

4.8(136)
439
LED-politielichten
AR-4Beginner

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.

4.7(105)
282
LED aansturen met een drukknop (Push)
AR-9Beginner

LED aansturen met een drukknop (Push)

Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

4.8(114)
253
LED schakelen met een knop (aan/uit)
AR-10Beginner

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.

4.7(103)
177
Nachtlampje met LDR
AR-12Beginner

Nachtlampje met LDR

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

4.7(105)
224
LED-looplicht
AR-5Gemiddeld

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.

4.6(87)
217
Afstand meten met HC-SR04 (Serial-weergave)
AR-27Beginner

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.

4.6(50)
82