Arduino programmeren met blokken: laat een LED knipperen met blokken en C++ naast elkaar
Arduino programmeren met blokken voor beginners: sluit een LED aan met een weerstand van 220 Ω, zie de C++-regel achter elk blok, verander de wachttijd van 100 ms en bouw daarna een stoplicht.
Bij Arduino programmeren met blokken is het eerste programma bijna altijd hetzelfde: een LED laten knipperen. In dit artikel doen we dat van begin tot eind. We sluiten een LED aan op pin 9 via een weerstand van 220 Ω, lezen de blokken van het project LED Blink in BlueGrays één voor één door en zien naast elkaar in welke regel C++-code op het board elk blok verandert. Je probeert ook één getal aan te passen, de 100 in het blok "wacht 100 ms", om te bepalen hoe snel de LED knippert.
We blijven niet bij één LED. We laten dezelfde logica stap voor stap uitgroeien tot programma's die twee LED's om de beurt laten knipperen, zich gedragen als een stoplicht en flitsen als politielichten. Daarna zie je hetzelfde idee op de ESP32 en op de Raspberry Pi Pico met MicroPython. Aan het eind staat een tabel met de fouten die bijna elke beginner een keer maakt. Elk project in dit artikel is gratis in BlueGrays, blokken en code inbegrepen, en op de pagina programmeren met blokken bekijk je alle projecten met blokken per platform.
Wat heb je nodig?
| Onderdeel | Aantal | Opmerking |
|---|---|---|
| Arduino Uno (of Nano) | 1 | Verbindt via USB met je computer |
| LED van 5 mm (rood is het makkelijkst) | 1 | Lang pootje +, kort pootje - |
| Weerstand van 220 Ω | 1 | Kleurbanden: rood, rood, bruin |
| Breadboard | 1 | Solderen is niet nodig |
| Jumperdraden male-to-male | 2 | Voor D9 en GND |
| Computer met de Arduino IDE | 1 | Om de code naar het board te uploaden |
De schakeling: de LED aansluiten op pin 9
Een LED heeft twee pootjes en de richting doet ertoe. Het lange pootje is de anode (+) en het korte pootje is de kathode (-); aan de kant van de kathode heeft de plastic behuizing een platte rand. Er loopt alleen stroom van anode naar kathode, dus als je de LED omgekeerd plaatst, gebeurt er niets. Sluit Arduino-pin 9 aan op het ene uiteinde van de weerstand van 220 Ω en het andere uiteinde van de weerstand op het lange pootje van de LED. Ga daarna met het korte pootje naar GND. De weerstand beperkt de stroom: trek de ongeveer 2 V die een rode LED nodig heeft af van 5 V en er blijft 3 V over de weerstand staan, en 3 V / 220 Ω is ongeveer 14 mA. Dat is prima voor de LED en veilig voor de Arduino-pin. De waarde voor jouw eigen LED-kleur controleer je met de LED-weerstandsrekenmachine. Hoe een LED werkt lees je in wat is een LED, en hoe de rijen van een breadboard van binnen verbonden zijn in wat is een breadboard.
| Aansluiting | Arduino Uno (LED Blink) | ESP32 (LED Blink with ESP32) | Raspberry Pi Pico (externe LED) |
|---|---|---|---|
| Lang pootje van de LED (anode, +) | D9 via 220 Ω | GPIO 5 via 220 Ω | GP14 via 220 Ω |
| Kort pootje van de LED (kathode, -) | GND | GND | GND |
| Pin in de blokken en code | 9 | 5 | LED_PIN = 14 |
| Wachttijd in het project | 100 ms | 500 ms | 0,5 seconde |
| Pinspanning | 5 V | 3,3 V | 3,3 V |
Je eerste programma in blokken: LED Blink
Als de schakeling klaar is, kijken we naar het programma. Open het project LED Blink in BlueGrays en zet in het codegedeelte Toon als blokken aan, dan zie je de onderstaande blokken. Het zijn er zeven in totaal, verdeeld over twee grote groepen: setup (eenmalig) bovenaan en herhaal voor altijd eronder. Blokken verschijnen in de taal van de app, dus in het Nederlands lees je "schrijf HIGH naar pin", terwijl hetzelfde blok in het Turks "numaralı pine YÜKSEK yaz" heet.

De blokken in setup (eenmalig) worden maar één keer uitgevoerd, wanneer het board stroom krijgt of je op reset drukt. Hier staat één blok: "zet pin 9 als OUTPUT". De digitale pins van de Arduino kunnen ingang of uitgang zijn. Omdat we een LED aansturen, zeggen we tegen het board: "ik stuur via deze pin stroom naar buiten". De groep herhaal voor altijd begint zodra setup klaar is en wordt van boven naar beneden steeds opnieuw uitgevoerd zolang het board aan staat. De vier blokken daarin zetten de LED aan, wachten 100 milliseconden, zetten hem uit en wachten weer 100 milliseconden. Na het laatste blok springt het programma terug naar boven en gaat de LED weer branden. Wat wij knipperen noemen, is gewoon die vier stappen vijf keer per seconde herhaald.
Blok → C++-regel: wat wordt elk blok?
| Blok | C++-regel | Wat het doet |
|---|---|---|
| setup (eenmalig) | void setup() { ... } | Voert de inhoud één keer uit bij het opstarten |
| zet pin 9 als OUTPUT | pinMode(9,OUTPUT); | Maakt van pin 9 een uitgang |
| herhaal voor altijd | void loop() { ... } | Herhaalt de inhoud eindeloos |
| schrijf HIGH naar pin 9 | digitalWrite(9,HIGH); | Zet 5 V op de pin, de LED gaat branden |
| wacht 100 ms | delay(100); | Pauzeert het programma 0,1 s |
| schrijf LOW naar pin 9 | digitalWrite(9,LOW); | Zet de pin op 0 V, de LED gaat uit |
| wacht 100 ms | delay(100); | Blijft 0,1 s uit |
1// Led Yakma (proje 1): D9'daki LED 100 ms yanar, 100 ms söner
2// LED Blink (project 1): the LED on D9 is on for 100 ms, off for 100 ms
3void setup() {
4 pinMode(9,OUTPUT); // LED pini çıkış / LED pin as output
5}
6
7void loop() {
8 digitalWrite(9,HIGH); // LED'i yak / turn the LED on
9 delay(100); // 100 ms bekle (1000 ms = 1 s) / wait 100 ms (1000 ms = 1 s)
10 digitalWrite(9,LOW); // LED'i söndür / turn the LED off
11 delay(100); // 100 ms bekle / wait 100 ms
12}
13Leg de tabel naast de code en je ziet wat de blokken voor je regelen. De vorm van de groepen setup en herhaal voor altijd komt overeen met de accolades van de functies void setup() en void loop(): de groep waarin een blok zit bepaalt tussen welke accolades zijn regel komt te staan. Met blokken hoef je niet te letten op de puntkomma aan het eind van elke instructie, hoofdletters en kleine letters (pinMode, digitalWrite) of haakjes. Zodra je zelf de code in de Arduino IDE gaat bewerken, tellen ze wel mee; één ontbrekende puntkomma is genoeg voor een compileerfout. Dat is het echte voordeel van blokken: je krijgt eerst de logica van het programma recht en leert daarna hoe diezelfde logica in code wordt geschreven.
Wat gebeurt er als je "wacht 100 ms" verandert?
De wachttijd is in milliseconden (ms) en 1000 ms is één seconde. Beide wachtblokken in het project zijn 100 ms, dus de LED is 0,1 seconde aan en 0,1 seconde uit. Eén hele cyclus duurt 200 ms, wat betekent dat de LED vijf keer per seconde knippert. Verhoog je het getal in beide blokken, dan gaat de LED langzamer; verlaag je het, dan gaat hij sneller. Onder een bepaalde grens kan je oog de knipperingen niet meer uit elkaar houden en lijkt de LED continu aan te staan. De tabel laat zien wat je ziet als je de twee wachttijden verandert:
| Wachtblokken | Eén hele cyclus | Knipperingen per seconde | Wat je ziet |
|---|---|---|---|
| 10 ms + 10 ms | 20 ms | 50 | Lijkt continu aan, iets zwakker |
| 100 ms + 100 ms (waarde in het project) | 200 ms | 5 | Snel, duidelijk knipperen |
| 250 ms + 250 ms | 500 ms | 2 | Makkelijk te volgen knipperen |
| 500 ms + 500 ms | 1 s | 1 | Eén keer per seconde, een rustig ritme |
| 1000 ms + 1000 ms | 2 s | 0,5 | 1 seconde aan, 1 seconde uit |
| 100 ms + 900 ms | 1 s | 1 | Korte flits, lange duisternis |
Het programma uitbreiden: twee LED's, een stoplicht, politieknipperlichten
Als je één LED kunt laten knipperen, heb je niets nieuws nodig om er meerdere aan te sturen; je herhaalt gewoon dezelfde drie blokken met andere pins. In het project Twee LED's om en om laten knipperen worden in setup twee pins uitgangen: 8 en 9. In herhaal voor altijd komen "schrijf HIGH naar pin 8" en "schrijf LOW naar pin 9", daarna "wacht 200 ms". Dan wordt het omgekeerde geschreven en wacht het programma weer 200 ms. Het trucje is dat de twee schrijfblokken direct na elkaar worden uitgevoerd, zonder wachttijd ertussen, zodat de twee LED's op hetzelfde moment lijken om te wisselen. Het wachtblok bepaalt hoe lang elke toestand duurt.
Het project Stoplicht past hetzelfde idee toe op drie LED's: rood op D2, geel op D3, groen op D4. De groep herhaal voor altijd heeft vier fasen en elke fase volgt hetzelfde patroon: één blok schrijf HIGH of schrijf LOW voor elk van de drie LED's, daarna één wachtblok. De schrijfblokken bepalen welke LED aan blijft en het wachtblok bepaalt hoe lang. Meer blokken maken het niet moeilijker, alleen langer. Een versie die dichter bij een echt kruispunt ligt, met een knop voor voetgangers, staat in het artikel Arduino-stoplicht.

| Fase | Rood (D2) | Geel (D3) | Groen (D4) | Wachttijd |
|---|---|---|---|---|
| 1 | HIGH | LOW | LOW | 2000 ms (2 s) |
| 2 | LOW | HIGH | LOW | 300 ms |
| 3 | LOW | LOW | HIGH | 2000 ms (2 s) |
| 4 | LOW | HIGH | LOW | 300 ms |
1// Trafik Lambası (proje 3) / Traffic Light (project 3)
2void setup() {
3 pinMode(2,OUTPUT); // Kırmızı / Red
4 pinMode(3,OUTPUT); // Sarı / Yellow
5 pinMode(4,OUTPUT); // Yeşil / Green
6}
7
8void loop() {
9 // Kırmızı yanar, 2 s bekle / Red on, wait 2 s
10 digitalWrite(2,HIGH);
11 digitalWrite(3,LOW);
12 digitalWrite(4,LOW);
13 delay(2000);
14 // Sarı yanar, 0,3 s bekle / Yellow on, wait 0.3 s
15 digitalWrite(2,LOW);
16 digitalWrite(3,HIGH);
17 digitalWrite(4,LOW);
18 delay(300);
19 // Yeşil yanar, 2 s bekle / Green on, wait 2 s
20 digitalWrite(2,LOW);
21 digitalWrite(3,LOW);
22 digitalWrite(4,HIGH);
23 delay(2000);
24 // Sarı yanar, sonra başa (kırmızıya) dön / Yellow on, then back to red
25 digitalWrite(2,LOW);
26 digitalWrite(3,HIGH);
27 digitalWrite(4,LOW);
28 delay(300);
29}
30Het project LED-politielichten introduceert twee nieuwe soorten blokken. De eerste is de groep globale variabelen (bovenaan) met daarin het blok "declareer geheel getal (int) delayTime = 60". Dat is de regel int delayTime = 60; in de code en die geeft de flitstijd een naam. Doordat de wachtblokken delayTime gebruiken in plaats van een getal, verander je de snelheid door alleen die 60 aan te passen, in plaats van vier losse blokken. Het tweede is het groene blok "herhaal 3 keer"; dat voert de vier blokken erin drie keer uit en wordt in C++ de lus for(int i=0;i<3;i++).

Even rekenen: bij elke flits is de rode LED 60 ms aan en 60 ms uit, dus één flits duurt 120 ms. Drie flitsen zijn 360 ms, en hetzelfde geldt voor de blauwe LED. Een hele cyclus duurt ongeveer 0,7 seconde. Zet delayTime op 30 en de lichten flitsen twee keer zo snel; zet hem op 120 en ze gaan langzamer. Variabelen en lussen zijn het onderwerp van deel 4 van de serie, waarin we ze uitgebreid behandelen in de blokken "herhaal voor altijd", teller en array. Het project LED-looplicht, dat het licht langs een rij LED's laat lopen, is de volgende stap op dezelfde weg.
Hetzelfde idee op de ESP32 en de Raspberry Pi Pico
Op de ESP32 zijn de blokken bijna identiek aan die van de Arduino, omdat de ESP32 ook in C++ met de Arduino IDE wordt geprogrammeerd. In het project LED Blink met ESP32 zit de LED op GPIO 5 en zijn de wachtblokken 500 ms. De coderegels zijn ook hetzelfde: pinMode(5, OUTPUT); digitalWrite(5, HIGH); delay(500);. De enige verschillen zijn het pinnummer, het feit dat ESP32-pins 3,3 V leveren, en dat je in de Arduino IDE een ESP32-board kiest. Alles wat je op de Uno leert, werkt direct door op de ESP32.
In projecten met de Raspberry Pi Pico worden de blokken MicroPython-code en veranderen de blokinamen een beetje. In het project Pico met externe LED zit de LED op GP14. Het blok "pin led : GP LED_PIN, OUTPUT" komt overeen met led = Pin(LED_PIN, Pin.OUT), "zet aan (on) pin led" met led.on(), "wacht 0,5 seconden" met time.sleep(0.5) en herhaal voor altijd met de lus while True:. Let op dat de wachttijd in MicroPython in seconden is, niet in milliseconden; delay(500) van Arduino wordt time.sleep(0.5). Wil je het zonder bedrading proberen, dan laat het project Pico met ingebouwde LED de LED op GP25 op het board zelf branden; op een Pico W spreek je de ingebouwde LED aan met de naam "LED" in plaats van GP25.
1# Pico harici LED (proje 8163), seri port satırları çıkarıldı
2# Pico external LED (project 8163), serial print lines removed
3from machine import Pin
4import time
5
6LED_PIN = 14 # GP14, herhangi bir boş GPIO / any free GPIO
7led = Pin(LED_PIN, Pin.OUT) # pini çıkış yap / set the pin as output
8
9while True: # sürekli tekrarla / loop forever
10 led.on() # LED'i yak / turn the LED on
11 time.sleep(0.5) # 0,5 saniye bekle / wait 0.5 s
12 led.off() # LED'i söndür / turn the LED off
13 time.sleep(0.5)
14Veelgemaakte fouten en hoe je ze oplost
| Fout | Symptoom | Oplossing |
|---|---|---|
| LED omgekeerd geplaatst | De LED gaat nooit branden | Lang pootje via de weerstand naar de pin, kort pootje naar GND; draai de LED om |
| Geen weerstand | LED te fel, wordt heet, kan snel kapotgaan | Plaats een weerstand van 220 Ω in serie met de LED |
| Pin in het blok wijkt af van de schakeling | Uploaden lukt, maar de LED blijft donker | De 9 in het blok en de D9 die je hebt aangesloten moeten overeenkomen; pas de draad of het getal aan |
| Tweede wachtblok vergeten | De LED lijkt continu aan | Ook na het blok schrijf LOW moet een wachtblok (delay) staan |
| Wachttijd te kort (bijv. 5 ms) | LED lijkt continu aan en iets zwak | Probeer minstens 50–100 ms |
| Beide LED-pootjes in dezelfde rij van het breadboard | De LED gaat nooit branden | Plaats de pootjes in verschillende rijen; gaatjes in dezelfde rij zijn van binnen verbonden |
| Verkeerd board of verkeerde poort gekozen | De Arduino IDE geeft een uploadfout | Kies het juiste board en de juiste poort in het menu Tools |
Stap voor stap in de app: van blokken naar het board
- Open in BlueGrays het project LED Blink, dat in de projectlijst het blokkenbadge heeft. Je kunt ook het filter gebruiken om alleen projecten met blokken te tonen.
- Plaats volgens het schakelschema de LED, de weerstand van 220 Ω en twee draden op het breadboard.
- Zet in het codegedeelte Toon als blokken aan. De blokken vervangen de code; tik op de afbeelding om hem schermvullend te openen.
- Ga naar het tabblad Blokken uitgelegd. Het programma wordt stap voor stap uitgelegd en bij elke stap zie je alleen de eigen blokken en wat ze doen.
- Zet de schakelaar uit om terug te gaan naar de echte code, kopieer die en plak hem in de Arduino IDE. Blokken worden niet rechtstreeks naar het board geüpload; het is altijd deze code die erop komt.
- Kies in de Arduino IDE Arduino Uno als board, kies de juiste poort en druk op Upload. Heb je de IDE nog niet geïnstalleerd, dan loopt het artikel Arduino IDE installeren je er stap voor stap doorheen.
- Zodra de LED knippert, verander je beide regels delay(100) in delay(1000), upload je opnieuw en zie je zelf het verschil.
In dit artikel knipperde de LED steeds in hetzelfde ritme; het programma luisterde nooit naar de buitenwereld. De volgende stap is het board beslissingen laten nemen: deel 3 van de serie, de knop en het "als"-blok, behandelt een programma dat de LED laat branden als je op een knop drukt en hoe het "als"-blok in C++ een if/else wordt.
In de BlueGrays-app bekijk je LED Blink, Twee LED's om en om laten knipperen, Stoplicht, LED-politielichten en de LED-projecten voor ESP32 en Pico met hun schakelschema's en code, schakel je met Toon als blokken over naar de blokversie van hetzelfde programma en lees je met Blokken uitgelegd wat elke stap doet.
Veelgestelde vragen
Wat is Arduino programmeren met blokken?
Het is een manier om een Arduino-programma te tonen als blokken die als puzzelstukjes in elkaar klikken, in plaats van getypte tekst. Elk blok, zoals "schrijf HIGH naar pin 9" of "wacht 100 ms", komt overeen met één regel van de C++-code die naar het board wordt geüpload. Zonder puntkomma's of haakjes om je zorgen over te maken, kunnen beginners zich eerst op de logica van het programma richten.
Hoe laat je een LED knipperen met blokken?
Zet "zet pin 9 als OUTPUT" in de groep setup en "schrijf HIGH naar pin 9", "wacht 100 ms", "schrijf LOW naar pin 9" en "wacht 100 ms" in de groep herhaal voor altijd. In de schakeling gaat de LED via een weerstand van 220 Ω naar D9. Deze blokken worden de regels pinMode, digitalWrite en delay.
Waarom brandt mijn LED continu in plaats van te knipperen?
De meest voorkomende reden is een ontbrekend wachtblok na het blok schrijf LOW. De LED is dan maar enkele microseconden uit en je oog merkt dat niet. Zijn de wachttijden heel kort (bijvoorbeeld 5 ms), dan lijkt de LED ook continu aan; probeer 100 ms of meer.
Welke weerstand gebruik ik voor een LED op Arduino?
Op de 5V-pins van een Arduino Uno is 220 Ω de gebruikelijkste keuze en laat ongeveer 14 mA door een rode LED lopen. 330 Ω werkt ook, met een iets zwakkere LED. De weerstand beperkt de stroom aan welk LED-pootje hij ook zit; het gaat erom dat hij in serie staat.
Kan ik de blokken rechtstreeks naar de Arduino uploaden?
Nee. De blokken in BlueGrays maken het programma makkelijker te lezen en te begrijpen; het board krijgt altijd de echte code van het project. Die code kopieer je naar de Arduino IDE (Thonny voor de Pico) en upload je van daaruit.
Hoeveel seconden is 1000 ms en hoe verander ik de knippersnelheid?
1000 milliseconden is 1 seconde. Een groter getal in de wachtblokken maakt de LED langzamer, een kleiner getal sneller: met beide blokken op 100 ms knippert de LED 5 keer per seconde, bij 500 ms één keer per seconde. In de MicroPython-blokken van de Pico wordt de tijd in seconden geschreven, dus 0.5 is een halve seconde.
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.

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.

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

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

