Basis · 12 min leestijd

Wat is programmeren met blokken? Zo worden blokprogramma's echte code

Wat is programmeren met blokken en hoe werkt het? Blokkleuren, setup en loop, en een LED Blink-voorbeeld dat blokken omzet naar C++ en MicroPython.

Programmeren met blokken is een manier om een programma te bouwen door kleurrijke blokken als puzzelstukjes op elkaar te stapelen in plaats van het regel voor regel te typen. Elk blok is één instructie, zoals "zet de pin als uitgang", "zet de LED aan" of "wacht 100 ms". Omdat blokken alleen passen waar ze horen, kunnen fouten zoals een ontbrekende puntkomma, een niet gesloten haakje of een verkeerd gespeld commando gewoon niet voorkomen, en kun je je op de logica van het programma richten. Daarom wordt blokprogrammeren algemeen gezien als de zachtste manier om met programmeren te beginnen voor kinderen en beginners.

Dit artikel is deel 1 van de serie Van blokken naar code. In het volgende deel bouwen we het eerste programma met blokken: een LED laten knipperen met blokken.

Maar programmeren met blokken is geen speelgoedtaal. Achter elk blokprogramma dat naar een Arduino of een Raspberry Pi Pico gaat, zit echte code, en het board voert altijd die code uit. In dit artikel zie je wat blokken zijn, wat hun kleuren je vertellen en hoe een blokprogramma stap voor stap verandert in echte C++- of MicroPython-code, aan de hand van gratis BlueGrays-projecten. Aan het eind vind je ook de sterke punten en grenzen van blokprogrammeren en hoe het samengaat met tools als Scratch, mBlock en Tinkercad.

Blokken van het project LED Blink: setup (één keer uitgevoerd) en loop (herhaalt eindeloos)
Het project LED Blink als blokken: het setup-blok zet pin 9 als OUTPUT en het blok voor eindeloos herhalen zet de LED 100 ms aan en 100 ms uit. Hieronder koppelen we dit kleine programma regel voor regel aan de C++-code.

Wat is programmeren met blokken en waarom heet het "blokken"?

Bij programmeren met blokken is elke instructie een stuk met inkepingen en uitsteeksels aan de randen. Het uitsteeksel onderaan een blok past in de inkeping van het blok eronder, zodat de instructies van boven naar beneden in volgorde worden uitgevoerd. Sommige blokken hebben een open mond: dat zijn containerblokken die andere blokken bevatten. Andere hebben witte ovale vakjes waarin je een getal of een ander waardeblok steekt. Omdat de vorm van elk stuk bepaalt wat waar kan, is het bijna onmogelijk een programma te bouwen dat de regels breekt. De meeste blokeditors van nu volgen het pad dat is geopend door Scratch van MIT en de opensourcebibliotheek Blockly van Google. De blokken in BlueGrays zijn ook op Blockly gebaseerd; we hebben de blokkenset zelf ontworpen voor elektronicaprojecten en tonen hem in de taal van de app. Houd er rekening mee dat blokken geen nieuwe programmeertaal zijn. Instructies, volgorde, voorwaarden, lussen en variabelen zijn precies dezelfde concepten als in tekstcode; blokken maken ze alleen zichtbaar.

Hoe wordt een blokprogramma echte code?

Blokeditors gebruiken op de achtergrond een codegenerator: elk bloktype heeft een sjabloon in tekstcode, en terwijl je blokken stapelt, worden die sjablonen in volgorde aan elkaar gezet. BlueGrays is iets strenger: de blokken van elk project zijn gebouwd om één op één overeen te komen met de echte code die op het board komt. Elke regel in de blokken heeft een tegenhanger in de code, en elke regel code heeft een tegenhanger in de blokken. In Arduino- en ESP32-projecten is die code C++; in Raspberry Pi Pico-projecten is het MicroPython. Om een blokprogramma te lezen hoef je alleen deze vijf onderdelen te kennen:

  • setup (één keer uitgevoerd): het deel dat maar één keer draait wanneer het board wordt gestart of gereset. Het komt overeen met de functie setup() in Arduino en hier zet je meestal pins als INPUT of OUTPUT.
  • loop (herhaalt eindeloos): het deel dat steeds opnieuw van boven naar beneden draait zolang het board aan staat. In Arduino is het de functie loop(), in MicroPython een while True:-lus.
  • Opdrachtblokken: blokken zoals "schrijf HIGH naar pin 9" of "wacht 100 ms" die in de containers worden gestapeld en elk één taak doen. De meeste zijn één regel tekstcode.
  • Waardeblokken: getallen zoals 9 of 100 in de witte ovalen, en afgeronde blokken die een resultaat geven, zoals "lees pin 13". Ze passen in de vakjes van opdrachtblokken en worden in de code de waarde tussen de haakjes.
  • Keuzelijsten: opties zoals OUTPUT / INPUT of HIGH / LOW. Ze komen overeen met de constanten OUTPUT / INPUT en HIGH / LOW in de code en omdat het menu alleen geldige opties biedt, kun je ze niet verkeerd spellen.

Genoeg theorie, laten we een echt voorbeeld bekijken. In het project LED Blink zijn een LED en een weerstand aangesloten op pin 9 en knippert de LED vijf keer per seconde. In de tabel hieronder zetten we de blokken uit de afbeelding hierboven één voor één om in code. Elke rij is één blok en elk blok is één regel code:

BlokC++-codeWat het doet
setup (één keer uitgevoerd)void setup() { … }De inhoud draait één keer wanneer het board start
zet pin 9 als OUTPUTpinMode(9,OUTPUT);Maakt van pin 9 een uitgang die de LED kan aansturen
eindeloos herhalenvoid loop() { … }De inhoud herhaalt zich zolang het board draait
schrijf HIGH naar pin 9digitalWrite(9,HIGH);Zet 5 V op de pin, de LED gaat aan
wacht 100 msdelay(100);Pauzeert het programma 100 milliseconden
schrijf LOW naar pin 9digitalWrite(9,LOW);Zet de pin op 0 V, de LED gaat uit
wacht 100 msdelay(100);Wacht 100 ms met de LED uit
C++ (Arduino IDE)
1void setup() {
2  pinMode(9,OUTPUT);     // LED pini çıkış / LED pin as output
3}
4
5void loop() {
6  digitalWrite(9,HIGH);  // LED'i yak / Turn the LED on
7  delay(100);            // 100 ms bekle (1000 ms = 1 sn) / Wait 100 ms (1000 ms = 1 s)
8  digitalWrite(9,LOW);   // LED'i söndür / Turn the LED off
9  delay(100);            // 100 ms bekle / Wait 100 ms
10}

De code bevat een paar dingen die je in de blokken niet ziet: het woord void, accolades en puntkomma's. Dit zijn syntaxisregels van C++, en bij blokken regelt de vorm zelf dat. De mond van een containerblok vervangt de accolades en blokken die onder elkaar zitten vervangen de volgorde van de regels. Als je de 100 in het waardevakje verandert in 1000, staat er in de code delay(1000) en knippert de LED één keer per seconde. Als je in het menu LOW kiest in plaats van HIGH, wordt HIGH een LOW. Dankzij deze één-op-één-overeenkomst begin je na een paar projecten de code te lezen zonder naar de blokken te kijken. De schakeling en de stapsgewijze bouw van ditzelfde project vind je in deel 2 van de serie: een LED laten knipperen met blokken.

Blokken worden niet rechtstreeks naar het board geüpload. In BlueGrays maken de blokken het programma gemakkelijker te lezen en te begrijpen; wat op het board komt, is altijd de echte code van hetzelfde project. Voor Arduino- en ESP32-projecten kopieer je de code naar de Arduino IDE, voor Pico-projecten naar Thonny, en upload je hem van daaruit.

Wat betekenen de blokkleuren?

In blokeditors is kleur geen versiering; het laat zien uit welke categorie een blok komt. Als je voor het eerst naar een programma kijkt, kun je het dankzij de kleuren lezen als "hier wordt een variabele gedeclareerd, hier wordt een beslissing genomen, hier is een lus". Dit zijn de categorieën die je ziet in de blokafbeeldingen van BlueGrays-projecten:

KleurCategorieVoorbeeldblokken uit de afbeeldingenCode
BlauwgroenProgrammastructuur, pin-in-/uitvoer, wachtensetup (één keer uitgevoerd), eindeloos herhalen, zet pin … als OUTPUT, schrijf HIGH naar pin …, lees pin …, wacht … mssetup(), loop(), pinMode(), digitalWrite(), digitalRead(), delay()
Donker blauwgroenBlokken voor Pico-pins en timingpin led : GP LED_PIN, OUTPUT; zet aan (on) / zet uit (off) pin led; wacht 0,5 secondenPin(…, Pin.OUT), led.on(), led.off(), time.sleep()
OudrozeVariabelenglobale variabelen (bovenaan), declareer geheel getal (int) … = …, zet … op …int ledState = 0; ledState = …;
BlauwgrijsLogicaals … dan, vergelijkingen ≠ en =, niet …if, !=, ==, !
GroenLussentel met i van 0 tot 5 in stappen van 1for (int i = 0; i < 6; i++)
PaarsArraysarray 2 3 4 5 6 7, item i van ledPinsint ledPins[] = {2, 3, 4, 5, 6, 7}; ledPins[i]

Ook vormen geven aanwijzingen. Voorwaarde- en vergelijkingsblokken hebben spitse, zeshoekachtige uiteinden en passen in het voorwaardevakje van een "als"-blok, terwijl getal- en variabelenblokken afgeronde uiteinden hebben. Eén detail in de tabel is het opmerken waard: in het blok "tel met i van 0 tot 5 in stappen van 1" is de bovengrens inbegrepen, dus i krijgt de waarden 0, 1, 2, 3, 4 en 5. In code schrijf je dit met de voorwaarde i < 6, en de lus draait zes keer. Het project LED Chaser laat met precies dit blok zes LED's na elkaar branden; lus- en arrayblokken behandelen we uitgebreid in het deel over lussen en variabelen van de serie.

Blokken van het project Een LED schakelen met een knop (aan/uit): variabele-, logica- en pinblokken
Een LED schakelen met een knop (aan/uit): oudroze blokken zijn variabelen, blauwgrijze "als"-blokken zijn beslissingen en blauwgroene blokken lezen en schrijven pins. Elke druk op de knop schakelt de toestand van de LED om.

De geneste "als"-blokken in deze afbeelding worden in de code geneste if-regels. Het blok "als button ≠ lastButton" is de regel if (button != lastButton) en draait wanneer de toestand van de knop verandert. Het "als button = 1" daarbinnen vangt alleen het moment van indrukken. Het blok "zet ledState op niet ledState" is de regel ledState = !ledState;, die 0 in 1 en 1 in 0 verandert. Het blok "schrijf ledState naar pin 7" dat daarna komt, is digitalWrite(7, ledState);. Het hele project zie je op de pagina Een LED schakelen met een knop (aan/uit); het verband tussen het "als"-blok en if/else leggen we uit in het deel over knoppen en voorwaarden van de serie.

C++ op Arduino en ESP32, MicroPython op de Pico

Dezelfde blokkenlogica wordt op verschillende boards naar verschillende talen vertaald. In Arduino- en ESP32-projecten worden de blokken omgezet in C++-code en worden de blokken setup en eindeloos herhalen setup() en loop(). De blokken van het project LED Blink met ESP32 hebben bijvoorbeeld dezelfde structuur als LED Blink; alleen de pin is 5 en de vertraging 500 ms. In Raspberry Pi Pico-projecten worden de blokken MicroPython. Hier is geen functie setup(): wat in het setup-blok staat, wordt bovenaan het bestand regels die één keer draaien, en het blok eindeloos herhalen wordt een while True:-lus.

Blokken van het Raspberry Pi Pico-project met externe LED: pin- en timingblokken die MicroPython worden
Raspberry Pi Pico met externe LED op GP14: de donker blauwgroene blokken komen overeen met het Pin-object en het commando time.sleep() in MicroPython. De LED blijft een halve seconde aan en een halve seconde uit.
MicroPython
1from machine import Pin
2import time
3
4# ============ PIN ============
5LED_PIN = 14                    # Boştaki herhangi bir GPIO / Any free GPIO
6led = Pin(LED_PIN, Pin.OUT)     # led adlı pin, ÇIKIŞ / pin named led, OUTPUT
7
8print("== BlueGrays: Pico Harici LED Blink ==")
9print("LED pin: GP" + str(LED_PIN))
10print("500ms yakip 500ms sonduruyor / 500ms on 500ms off")
11
12# ============ ANA DÖNGÜ / MAIN LOOP ============
13while True:
14    led.on()                    # LED'i yak / Turn the LED on
15    print("[LED] ACIK / ON")
16    time.sleep(0.5)             # 0.5 saniye bekle / Wait 0.5 s
17
18    led.off()                   # LED'i söndür / Turn the LED off
19    print("[LED] KAPALI / OFF")
20    time.sleep(0.5)             # 0.5 saniye bekle / Wait 0.5 s

Je kunt de overeenkomst regel voor regel volgen. Het blok "declareer geheel getal (int) LED_PIN = 14" binnen "globale variabelen (bovenaan)" is de regel LED_PIN = 14; omdat Python geen typen schrijft, verschijnt het deel (int) niet in de code. Het blok "pin led : GP LED_PIN, OUTPUT" wordt led = Pin(LED_PIN, Pin.OUT). "zet aan (on) pin led" is led.on(), "wacht 0,5 seconden" is time.sleep(0.5) en "serial print" is een print()-regel. Het blok "maak tekst met" zet de tekst "LED pin: GP" en de waarde van LED_PIN met + naast elkaar. Let op: bij Arduino is de vertraging in milliseconden (100 ms), in MicroPython in seconden (0.5), en de blokken tonen dit verschil met aparte blokken "wacht … ms" en "wacht … seconden". Voor de schakeling zie je de pagina Raspberry Pi Pico met externe LED; als de Pico nieuw voor je is, helpt het om eerst wat is de Raspberry Pi Pico te lezen.

Voordelen en grenzen van programmeren met blokken

OnderwerpVoordeelGrens
SyntaxisfoutenGeen fouten met puntkomma's, haakjes of hoofdletters en kleine lettersLogische fouten komen nog steeds voor: een verkeerde pin of een verkeerde vertraging is ook in blokken fout
LeesbaarheidKleuren en vormen tonen de structuur van een programma in één oogopslagLange programma's nemen als blokken veel schermruimte in; tekstcode blijft compacter
LeersnelheidJe hebt je eerste programma in een paar minuten en concepten worden concreetAls je nooit bij blokken wegblijft, ontwikkelen vaardigheden met tekstcode, zoals foutmeldingen lezen, zich niet
BereikBasisbouwstenen zoals pins, wachttijden, voorwaarden, lussen, variabelen en serieel zijn beschikbaarNiet elke bibliotheek of hardwaredetail heeft een blok; gevorderde projecten vragen om tekstcode
Verband met het boardDezelfde logica ziet er vertrouwd uit op Arduino, ESP32 en PicoHet board voert altijd tekstcode uit, dus vroeg of laat moet je die kennen

Programmeren met blokken is niet het antwoord op alles; het is een brug. In de eerste weken is het een heel krachtige manier om de logica van een programma te begrijpen, en het echte doel is om die brug op een gegeven moment over te steken en zelfverzekerd naar tekstcode te kijken. Blokken en code naast elkaar zien versnelt die stap, want in elk nieuw project zie je dezelfde blokken steeds weer in dezelfde regels veranderen. Als je het blok "eindeloos herhalen" in tien projecten hebt gezien, voelt het woord loop() niet meer vreemd. Als je klaar bent voor tekstcode, loopt Arduino-programmeren: de basis je met voorbeelden door alles heen, van variabelen tot functies.

Voor wie is programmeren met blokken?

  • Kinderen en gezinnen: kinderen vanaf 9-10 jaar die vlot lezen, kunnen samen met een volwassene beginnen. Met de blokken op het scherm en een LED die op het breadboard oplicht, is programmeren niet langer abstract.
  • Docenten en robotica-clubs: een project eerst met blokken uitleggen en dan naar de code overgaan, brengt verschillende niveaus samen in dezelfde les. Het lesplan dat we hiervoor hebben gemaakt, staat in het laatste deel van de serie: een lesplan robotica en programmeren met blokken.
  • Arduino-beginners: als je net je board hebt en de eerste sketches er verwarrend uitzien, zijn blokken de snelste manier om te zien wat elke regel doet. Om het board zelf te leren kennen, begin je met wat is Arduino.
  • Iedereen die code moeilijk leesbaar vindt: een programma begrijpen dat iemand anders heeft geschreven, is op zich een vaardigheid. Naar de blokken van een kant-en-klaar project kijken om de structuur te begrijpen, maakt het makkelijker te zien wat een lang stuk code waar doet.

Vergeleken met Scratch, mBlock, Tinkercad en MakeCode

De meeste tools die bij blokprogrammeren te binnen schieten, zijn editors die op een computer of in de browser draaien, en elk blinkt uit op zijn eigen terrein. Ze hebben gemeen dat je de blokken sleept en je eigen programma bouwt. BlueGrays beantwoordt een andere behoefte: het toont de blokken van kant-en-klare, geteste projecten naast het schakelschema, de onderdelenlijst en de echte code. In de app kun je (nog) niet je eigen blokken tot een programma rangschikken; in plaats daarvan lees je hoe een programma dat aantoonbaar werkt, is opgebouwd. Daarom concurreren deze tools niet maar vullen ze elkaar aan. Je kunt bijvoorbeeld een verkeerslichtsequentie die je in mBlock hebt gebouwd vergelijken met de blokken van het project Verkeerslicht, en als je nog geen board hebt, de schakeling simuleren in Tinkercad. Zie voor meer details de gidsen mBlock met Arduino en Tinkercad Arduino-simulatie.

ToolWie rangschikt de blokken?Waar het in uitblinkt
ScratchJij, op een computerEen eerste stap in programmeren met animaties, verhalen en games
mBlockJij, op een computerBoards zoals Arduino programmeren met blokken in Scratch-stijl en de gegenereerde code bekijken
Tinkercad CircuitsJij, in de browserVirtueel een schakeling bouwen en simuleren met blokken of tekstcode
MakeCodeJij, in de browserWisselen tussen blokken, JavaScript en Python voor boards zoals de micro:bit
BlueGraysKant-en-klaar, afgestemd op de code van het projectDe blokken van geteste projecten lezen naast echte code, schakelschema en onderdelenlijst

Programmeren met blokken gebruiken in de BlueGrays-app

  1. Kies een project met de blokbadge in Ontdekken › Projecten. Je kunt ook het filter gebruiken om alleen projecten met blokken te tonen. Meer dan 100 projecten in de app hebben blokken, de meeste Arduino-projecten en de rest ESP32- en Raspberry Pi Pico-projecten.
  2. Zet in het codegedeelte van het project de schakelaar Toon als blokken aan. De blokken van hetzelfde programma nemen de plaats van de code in; tik op de afbeelding om hem op volledig scherm te openen en comfortabel in te zoomen.
  3. Ga naar het tabblad Blokken uitgelegd. Het programma wordt stap voor stap uitgelegd: elke stap toont alleen de blokken van die stap en wat ze doen.
  4. Als je je afvraagt wat een commando doet, bekijk dan de Codegids. Elk voorbeeld daar wordt getoond met blokken en met Arduino- en MicroPython-commando's.
  5. Zet de schakelaar uit om terug te gaan naar de echte code. Kopieer hem, plak hem in de Arduino IDE (Thonny voor de Pico) en upload hem naar je board.
  6. Versterk wat je hebt geleerd met de Vragen van de dag: elke dag 5 vragen op niveaus van A1 tot C2, een wekelijkse ranglijst en badges.

Zowel de blokken als de code van 31 projecten zijn helemaal gratis; in de andere projecten worden de blokken met Premium ontgrendeld, net als de code. Een paar gratis projecten die een goede eerste stap zijn: LED Blink, Twee LED's die om en om knipperen, Verkeerslicht, LED Chaser, LED Blink met ESP32 en Raspberry Pi Pico: ingebouwde LED laten knipperen. Alle projecten met blokken per platform zie je op de pagina programmeren met blokken, waar je ook de blokken en de code van een voorbeeldproject naast elkaar kunt vergelijken.

Serie Van blokken naar code: de routekaart

  1. Wat programmeren met blokken is en hoe een blokprogramma echte code wordt (dit artikel)
  2. Het eerste programma: een LED laten knipperen met blokken, blokken en C++ naast elkaar
  3. Knoppen en voorwaarden: het "als"-blok en if/else
  4. Lussen en variabelen: eindeloos herhalen, tellen, arrays en tellers
  5. Sensoren uitlezen met blokken, de seriële poort en MicroPython op de Pico
  6. Voor docenten: een lesplan robotica en programmeren met blokken

In het volgende deel van de serie bouwen we het project LED Blink uit dit artikel helemaal opnieuw, met de schakeling, de blokken en de C++-code naast elkaar, in een LED laten knipperen met blokken. Tot dan kun je de hier genoemde projecten in de BlueGrays-app openen met hun schakelschema's en code, en met één tik overschakelen naar de blokversie van hetzelfde programma met Toon als blokken of naar een stapsgewijze uitleg met Blokken uitgelegd.

Veelgestelde vragen

Wat is programmeren met blokken?

Programmeren met blokken is een manier om programma's te bouwen door kleurrijke blokken te stapelen die als puzzelstukjes in elkaar passen, in plaats van commando's te typen. Elk blok is één instructie en de blokken worden van boven naar beneden in volgorde uitgevoerd. Omdat syntaxisfouten onmogelijk zijn, kunnen kinderen en beginners zich op de logica van het programma richten.

Wat is het verschil tussen programmeren met blokken en met tekst?

De concepten zijn hetzelfde: instructies, volgorde, voorwaarden, lussen en variabelen bestaan in beide. Het verschil zit in het schrijven; tekstcode vraagt om puntkomma's, haakjes en exacte spelling, terwijl bij blokken de vorm van de stukjes dat regelt. Voor lange en complexe programma's is tekstcode praktischer.

Voor welke leeftijd is programmeren met blokken?

Kinderen vanaf 9-10 jaar die vlot lezen, kunnen samen met een volwassene beginnen, en voor jongere kinderen zijn er blokkentools op basis van plaatjes. Er is geen bovengrens voor de leeftijd; ook volwassenen die nieuw zijn met Arduino hebben veel baat bij blokken in hun eerste projecten.

Welke programma's worden gebruikt voor programmeren met blokken?

De bekendste zijn Scratch, mBlock, Tinkercad Circuits en MakeCode, waarin je op een computer blokken sleept en je eigen programma bouwt. In de BlueGrays-app lees je de blokken van kant-en-klare, geteste Arduino-, ESP32- en Pico-projecten naast hun echte code. Deze tools vullen elkaar aan.

Kun je een Arduino programmeren met blokken?

Ja, maar het board voert altijd tekstcode uit. Tools zoals mBlock vertalen de blokken op de achtergrond naar Arduino-code en uploaden die. In BlueGrays komen de blokken één op één overeen met de C++-code van het project; om te uploaden kopieer je de code en plak je hem in de Arduino IDE.

Hoe stap je over van blokken naar tekstcode?

De effectiefste manier is om de blokken en de code van hetzelfde programma naast elkaar te bekijken. Nadat je in een paar projecten hebt gevolgd in welke regel elk blok verandert, begin je code te lezen zonder de blokken. Probeer dan kleine aanpassingen rechtstreeks in de code, bijvoorbeeld de vertraging of het pinnummer veranderen.

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(197)
1240
Twee LED's om en om laten knipperen
AR-2Beginner

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.

4.6(109)
360
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(135)
438
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
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
Led laten knipperen met ESP32
ES-1Beginner

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.

4.7(37)
107
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