111 blokprojecten · Arduino · ESP32 · Pico
Programmeren met blokken voor Arduino-, ESP32- en Pico-projecten
Volg kleurrijke blokken in plaats van code regel voor regel te lezen. 111 BlueGrays-projecten hebben een blokversie, en elk blok komt overeen met een regel van de echte code die op het board draait.
Wat is programmeren met blokken?
Programmeren met blokken betekent dat je een programma bouwt met puzzelachtige blokken in plaats van het te typen. "Pin als uitgang instellen", "LED aanzetten" en "1 seconde wachten" zijn elk een blok, en door ze op elkaar te stapelen bouw je het programma. Je hoeft je geen zorgen te maken over puntkomma's, haakjes of typefouten, dus je kunt je op de logica richten.
BlueGrays gebruikt een eigen blokkenset, en de blokken spreken jouw taal: staat de app in het Nederlands, dan staat er in de blokken "herhaal voor altijd" en "schrijf HIGH naar pin". In Arduino- en ESP32-projecten horen de blokken bij C++-code, in projecten met de Raspberry Pi Pico bij MicroPython.
Het doel is niet om eeuwig bij blokken te blijven, maar om de code te begrijpen. Leg de blokken van een project naast de code en je ziet wat elke regel doet. Na een paar projecten begin je de code ook zonder blokken te lezen.
Zo werkt programmeren met blokken in BlueGrays
In de app staan de blokken in het codegedeelte van elk blokproject. In vier stappen:
- 01
Kies een blokproject
Projecten met de blokbadge hebben een blokversie. Je kunt de lijst ook filteren, zodat alleen blokprojecten worden getoond.
- 02
Zet "Tonen als blokken" aan
Met één schakelaar in het codegedeelte verandert de code in blokken. Tik op de afbeelding om hem op volledig scherm te openen en in te zoomen.
- 03
Blokken uitgelegd
Het tabblad "Blokken uitgelegd" loopt het programma stap voor stap met je door en toont per stap alleen de bijbehorende blokken en wat ze doen.
- 04
Ga over op echte code
Zet de schakelaar uit en hetzelfde programma verschijnt als code. Kopieer die naar de Arduino IDE (of Thonny voor de Pico) en upload hem naar je board.
Eén programma: blokken en code
Links de blokken van het project, rechts de code die op het board draait. Bij elk blok hoort een regel code.
Blokken

Code
1// ─────────────────────────────────────────
2// BlueGrays · bluegrays.com
3// LED laten knipperen
4// ─────────────────────────────────────────
5// Laat een enkele LED elke 100 ms aan en uit knipperen. Laat het
6// basisgebruik van de functies digitalWrite en delay zien.
7//
8// Pinnen:
9// D9 -> LED (met een weerstand van 220 ohm)
10
11void setup() {
12 pinMode(9,OUTPUT); // LED-pin als uitgang
13}
14
15void loop() {
16 digitalWrite(9,HIGH); // Led aan
17 delay(100); // Wacht 100 ms (1000 ms = 1 s)
18 digitalWrite(9,LOW); // Led uit
19 delay(100);
20}
21Blokprojecten
Alle projecten met een blokversie, per platform. Gratis projecten staan bovenaan: 31 ervan zijn helemaal gratis, inclusief blokken en code.
Arduino-projecten74 blokprojecten

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.

Twee LED's om en om laten knipperen
Twee LED's knipperen snel om de beurt: als de ene aangaat, gaat de andere uit, alsof ze elkaar een bal toegooien.

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

Knight Rider-ledeffect
Het klassieke scannerlicht: een lichtpunt schuift van het ene uiteinde van zes LED's naar het andere en komt dan terug.

LED-looplicht met instelbare snelheid
Zes LED's gaan na elkaar aan, zodat het licht van het ene uiteinde naar het andere lijkt te rennen.

Knight Rider-ledeffect met instelbare snelheid
Een licht rent van het ene uiteinde van zes LED's naar het andere, draait om en rent weer terug.
Arduino-projecten: alle blokprojecten
- AR-9LED aansturen met een drukknop (Push)Gratis
- AR-10LED schakelen met een knop (aan/uit)Gratis
- AR-11Lichtsterkte meten met een LDRGratis
- AR-12Nachtlampje met LDRGratis
- AR-13Een buzzer gebruikenGratis
- AR-14Frequentie instellen met een buzzerGratis
- AR-27Afstand meten met HC-SR04 (Serial-weergave)Gratis
- AR-37Een reedschakelaar uitlezenGratis
- AR-45DS1302 RTC-klokmodule instellenGratis
- AR-55Temperatuur en luchtvochtigheid met DHT11Gratis
- AR-613x4-keypad gebruikenGratis
- AR-16Codes van een IR-afstandsbediening uitlezen
- AR-17Led aan- en uitzetten met IR-ontvanger en afstandsbediening
- AR-19230V-lamp laten branden met een drukknop
- AR-20230V-lamp laten branden met een knop (aan/uit)
- AR-21230V-lamp laten branden met een afstandsbediening
- AR-22Laserwaarschuwingssysteem
- AR-23Lasersysteem voor beveiliging
- AR-24Bewegingsmelder met bewegingssensor
- AR-25Deurbel en licht met bewegingssensor
- AR-26Eenvoudige piano met buzzer en knoppen
- AR-28Parkeersensor met HC-SR04
- AR-29Een bericht tonen op een 2x16-lcd-scherm
- AR-30Stuiterende tekstanimatie op een lcd
- AR-31Afstand meten met een lcd-scherm
- AR-32Een lcd-scherm gebruiken met I2C
- AR-33Lengtemeetproject
- AR-34LED bedienen met je telefoon via Bluetooth
- AR-35Een servomotor gebruiken
- AR-36Servomotor aansturen met een potentiometer
- AR-38Deursensor met reedschakelaar
- AR-39Een RGB-led gebruiken
- AR-40Vloeiende kleurovergang met een RGB-led
- AR-42Getallen van 0-99 tonen op een 7-segmentdisplay
- AR-43Teller met 7-segmentdisplay en knoppen
- AR-44Temperatuur meten met NTC en 2x16 LCD-display
- AR-46DS1302 RTC-klok met LCD-display
- AR-470-9999 tonen op een 7-segmentdisplay met 4 cijfers
- AR-48Digitale klok met 7-segmentdisplay met 4 cijfers
- AR-49Bomanimatie met 7-segmentdisplay met 4 cijfers
- AR-50Een vlamsensor gebruiken
- AR-51Een gassensor gebruiken
- AR-52Alarm met vlam- en gassensor
- AR-53RFID-waarde uitlezen
- AR-54RFID-authenticatie
- AR-56Digitale voltmeter met lcd-scherm
- AR-58Tweerichtingscommunicatie tussen 2 Arduino's
- AR-59Led bedienen met joystick
- AR-60Servo's bedienen met joystick
- AR-62Leds bedienen met een 3x4-keypad
- AR-634x4-keypad gebruiken
- AR-64Codeslot met 4x4-keypad en LCD
- AR-67Een stappenmotor gebruiken
- AR-68360-gradenservo van een stappenmotor
- AR-69Een WS2812B-ledstrip gebruiken
- AR-70Politieknipperlicht met WS2812B
- AR-71WS2812B-looplicht
- AR-72WS2812B-looplicht (opbouweffect)
- AR-73WS2812B Knight Rider-effect
- AR-74WS2812B Knight Rider-effect (3 leds)
- AR-75WS2812B-animatie 1
- AR-77Reflectie (nabijheid) meten met de TCRT5000
- AR-78Zwart-wit ondergrond herkennen met TCRT5000
- AR-82Slimme trap- en gangverlichting
- AR-83Slim bewateringsstation
- AR-95Arduino-reactietest met geluidssignaal: meet je reflexen in milliseconden (LCD + buzzer + 3 leds)
ESP32-projecten23 blokprojecten

Led laten knipperen met ESP32
Leert je het basisgebruik van een GPIO-uitgang met de ESP32. Door een led via een digitale pin aan en uit te zetten krijgen we een knippereffect. Dit is de ESP32-versie van het klassieke blinkproject op de Arduino UNO; de basiscommando's in de Arduino-omgeving zijn hetzelfde, maar de pinindeling en de 3,3 V-GPIO-niveaus van de ESP32 verschillen van die van de Arduino UNO.

ESP32-ledbesturing met drukknop (Push)
De led brandt zolang je de knop indrukt en gaat uit als je loslaat. Laat zien hoe je de digitale ingangspin en de interne pull-upweerstand van de ESP32 gebruikt. Met de modus INPUT_PULLUP heb je geen externe weerstand nodig.

ESP32-ledbesturing met drukknop (Toggle)
Elke keer dat je op de knop drukt, verandert de led van stand: is hij aan, dan gaat hij uit; is hij uit, dan gaat hij aan. Het klassieke togglepatroon. Met debounce filteren we de mechanische ruis van de drukknop weg, zodat één druk precies één wisseling geeft.

Ingebouwde led van de ESP32 laten knipperen
De ingebouwde blauwe led op de ESP32 DevKit V1 laten knipperen. Geen externe componenten nodig! Het eerste project dat je moet proberen als je een ESP32 koopt. GPIO 2 is verbonden met de ingebouwde led.

ESP32-stoplicht
Een echt stoplicht nabootsen met 3 leds: rood, geel en groen. De tijden lijken op de echte verkeerslogica: rood lang, geel kort, groen lang. Een klassiek voorbeeld van sequentiële GPIO-besturing.

ESP32 Knight Rider-ledlicht
6 leds die na elkaar van links naar rechts en van rechts naar links bewegen (Knight Rider-stijl). Een basisvoorbeeld van het gebruik van for-lussen en arrays. Leert je de logica van richtingswisseling.

ESP32-led dimmen met PWM
De helderheid van de led soepel veranderen van 0 naar max en van max naar 0. We sturen PWM aan met analogWrite() zoals bij Arduino; dezelfde syntaxis werkt zonder problemen met ESP32 Arduino Core 3.0+. Een pindefinitie, pinMode en analogWrite zijn genoeg.

ESP32 RGB-led aansturen
Onbeperkt kleuren maken met één RGB-led in plaats van 3 aparte leds. Net als op Arduino stel je met analogWrite() de R/G/B-waarden in en maak je een regenboogovergang. Kleurtheorie (zoals red+green=yellow) zie je in de praktijk.
ESP32-projecten: alle blokprojecten
- ES-11Lichtsterkte meten met de ESP32 en een LDR-moduleGratis
- ES-14ESP32 HC-SR04 ultrasone afstandssensorGratis
- ES-15ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)Gratis
- ES-20ESP32 MQ-2 gas-/rookmelderalarmGratis
- ES-21ESP32 RFID-RC522-kaartlezer (met LCD)Gratis
- ES-7ESP32 politieknipperlichteffect
- ES-10ESP32-nachtlampje met LDR
- ES-12Melodie afspelen met een buzzer op de ESP32
- ES-13ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)
- ES-16ESP32-servomotor (bediening met potentiometer)
- ES-17ESP32 I2C-LCD-display (16x2)
- ES-18Digitale klok met ESP32 en DS1307-RTC (I2C + LCD)
- ES-19Automatische verlichting met de ESP32 en een PIR-bewegingssensor
- ES-23ESP32 TM1637 4-cijferig 7-segmentdisplay
- ES-24ESP32 WS2812B NeoPixel-strip aansturen
Raspberry Pi Pico-projecten10 blokprojecten

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-politielicht met 3 flitsen per kleur (2 leds)
Een ritmische variant van het politielichtproject — flipflop met 3 flitsen! Dezelfde schakeling met 2 leds (GP11 rood + GP12 blauw), maar een ander patroon: de rode led flitst snel 3 keer, daarna flitst de blauwe 3 keer, eindeloos. Dit "flitsreeks + wissel"-patroon is het bekendste ritme van echte politiesirenes. Je leert de functie met parameters def burst(led, count, duration_ms), ritme ontwerpen en met code verschillende lichteffecten maken op dezelfde schakeling.

Raspberry Pi Pico: led aan/uit met een knop (toggle)
Knop + led, een niveau hoger! Je hoeft de knop niet ingedrukt te houden. Indrukken en loslaten → led aan. Nog een keer → led uit (toggle). Dezelfde schakeling (led GP14, knop GP2), maar andere code. Je leert edge detection (het moment van 1→0 vastleggen), toestand bijhouden en debounce (filter tegen contactdender). led.toggle() van MicroPython wisselt de toestand in één regel. De basis van interactieve knopprojecten.

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.
Raspberry Pi Pico-projecten: alle blokprojecten
Voor wie is het?
Kinderen en ouders
Programmeren blijft bij kinderen veel beter hangen als het eindigt met een LED die op tafel gaat branden. De blokken maken het programma leesbaar en de schakeling bouw je samen.
Docenten en clubs
In een les robotica of STEM kun je een project eerst met blokken uitleggen en daarna overstappen op de code. Bij elk project staan een onderdelenlijst en een schakelschema klaar.
Beginners
Arduino programmeren met blokken is de snelste manier om de logica van je eerste projecten te snappen. Begin met blokken en stap over op code als je er klaar voor bent.
Veelgestelde vragen
Wat is programmeren met blokken?
Het is een manier van programmeren waarbij commando's als blokken worden getoond die als puzzelstukjes op elkaar passen, in plaats van getypte tekst. Omdat je geen typefouten kunt maken, begrijpen beginners en kinderen de logica van een programma makkelijker.
Hoeveel BlueGrays-projecten hebben blokken?
Op dit moment 111: 76 Arduino-, 25 ESP32- en 10 Raspberry Pi Pico-projecten. De lijst groeit naarmate er meer projecten worden omgezet.
Is programmeren met blokken gratis?
De app is gratis. De blokken en de code van 31 blokprojecten zijn voor iedereen open. Bij de andere projecten worden de blokken, net als de code, ontgrendeld met Premium.
Kan ik de blokken direct naar mijn board uploaden?
Nee. De blokken maken het programma makkelijker te lezen en te begrijpen; wat op het board komt, is altijd de echte code van het project. Die kopieer je naar de Arduino IDE, of naar Thonny voor de Pico, en upload je.
Kan ik met de blokken mijn eigen programma's bouwen?
Nog niet. Wij maken de blokken voor elk project en laten ze één op één aansluiten op de code, zodat de blokken die je ziet altijd horen bij een geteste en werkende code.
Wat is het verschil met Scratch of mBlock?
In Scratch en mBlock sleep je blokken op een computer om je eigen programma te schrijven. In BlueGrays komt elk blokproject met een schakelschema, een onderdelenlijst en de echte code, en zijn de blokken een leesbare versie van die code. Ze vullen elkaar aan.
Is het geschikt voor kinderen? Vanaf welke leeftijd kunnen ze beginnen?
Kinderen van ongeveer 9 of 10 jaar die goed kunnen lezen, kunnen samen met een volwassene beginnen. De eerste projecten vragen geen solderen: ze worden op een breadboard gebouwd met LED's, knoppen en een buzzer.
In welke talen staan de blokken?
Engels, Turks, Duits, Spaans, Frans en Italiaans. De blokken verschijnen in de taal waarin je de app gebruikt.

