Van programmeren met blokken naar Arduino C++: spiekbrief met MicroPython
Spiekbrief van blokken naar Arduino C++: 34 rijen blokken met hun C++- en MicroPython-code, veelgemaakte fouten, een methode in 4 stappen en één programma in drie vormen.
De snelste manier om over te stappen van programmeren met blokken naar Arduino C++ is een tabel van één pagina naast je te leggen die laat zien welke regel echte code elk blok wordt. Het korte antwoord: blokken zijn geen nieuwe taal, ze zijn een visuele vorm van Arduino C++-regels. Het blok "zet pin 13 als OUTPUT" is de regel pinMode(13, OUTPUT);, het blok "wacht 1000 ms" is delay(1000); en het blok "als … dan" is een if-statement. In de tabel hieronder staan de echte labels van de blokken in de BlueGrays-app naast hun Arduino C++-code en hun MicroPython-code op de Raspberry Pi Pico.
Deze pagina is geen les, maar een naslagblad. Je kunt de tabel printen, naast je bureau leggen en opzoeken welke regel bij welk blok hoort terwijl je naar een project kijkt. Na de tabel vind je de meest gemaakte fouten bij het overstappen, een methode in vier stappen om de blokken achter je te laten en hetzelfde programma als blokken, C++ en MicroPython. Het voorbeeld compileert in de Arduino IDE en draait op de Pico met Thonny.

Voordat je de tabel leest: vier verschillen tussen de drie
Blokken, C++ en MicroPython drukken hetzelfde idee uit, maar de schrijfregels verschillen. Bij deze vier verschillen struikel je het vaakst. Het eerste is de structuur: een Arduino C++-programma heeft twee delen, setup() en loop(), die in blokken verschijnen als "setup (eenmalig)" en "herhaal voor altijd". MicroPython heeft geen aparte setup; het bestand wordt één keer van boven naar beneden uitgevoerd en het herhalende deel komt in een while True:-lus. Het tweede zijn de types: in C++ heeft elke variabele een opgeschreven type (int, float, bool), in blokken is dat de optie "declareer geheel getal (int)", en in Python wordt helemaal geen type geschreven.
Het derde verschil zijn de getalbereiken. Op de Arduino Uno is een analoge meting 0–1023 en PWM 0–255; op de ESP32 loopt een analoge meting tot 0–4095; op de Pico geeft MicroPython zowel metingen als PWM-duty in het bereik 0–65535. Daarom kun je een drempelwaarde niet zomaar van het ene board naar het andere kopiëren. Het vierde verschil is de tijdseenheid: delay() neemt milliseconden, time.sleep() neemt seconden. Een halve seconde is delay(500) in C++ en time.sleep(0.5) in MicroPython. Houd deze vier regels in gedachten en de meeste rijen van de tabel vallen vanzelf op hun plek.
- De getallen in de tabel zijn voorbeelden: waar een blok 13 zegt, kan jouw project 7 gebruiken, en het getal in de coderegel verandert mee.
- De pins in de MicroPython-kolom zijn GP-nummers van de Pico (GP14, GP15, GP26). Ze hoeven niet overeen te komen met de pinnummers van de Uno; kijk in het schakelschema.
- Rijen met "Geen Pico-blok" betekenen dat dat blok niet in Pico-projecten wordt gebruikt; MicroPython-code die hetzelfde doet wordt toch gegeven.
- De ESP32 wordt ook in Arduino C++ geprogrammeerd; de C++-kolom geldt dus ook voor dit board, alleen het analoge bereik en enkele pinnummers verschillen.
Naslagtabel voor blokken, Arduino C++ en MicroPython
De tabel is verdeeld in 12 groepen: programmastructuur, pins, tijd, voorwaarden, lussen, variabelen, rekenen, seriële poort, analoog en PWM, geluid, servo en sensor. De tekst in de kolom Blok is het label op de blokken in de app, en "…" en "?" geven de plek aan waar een ander blok in past. Als een rij meer dan één blok bevat, staan ze gescheiden door een punt (·).
| Groep | Blok (label in de app) | Arduino C++ | MicroPython (Pico) |
|---|---|---|---|
| Structuur | setup (eenmalig) | void setup() { … } | De regels vóór while True: |
| Structuur | herhaal voor altijd | void loop() { … } | while True: (inhoud 4 spaties ingesprongen) |
| Structuur | globale variabelen (bovenaan) | Bovenaan het bestand, vóór setup() | De eerste regels na de imports |
| Structuur | om blinkTwice | void blinkTwice() { … } · aanroep: blinkTwice(); | def blinkTwice(): · aanroep: blinkTwice() |
| Pins | zet pin 13 als OUTPUT | pinMode(13, OUTPUT); | led = Pin(15, Pin.OUT) |
| Pins | zet pin 2 als INPUT_PULLUP | pinMode(2, INPUT_PULLUP); | btn = Pin(14, Pin.IN, Pin.PULL_UP) |
| Pins | schrijf HIGH naar pin 13 · schrijf LOW naar pin 13 | digitalWrite(13, HIGH); · digitalWrite(13, LOW); | led.value(1) · led.value(0) |
| Pins | lees pin 2 | digitalRead(2) → HIGH (1) of LOW (0) | btn.value() → 1 of 0 |
| Pins (alleen Pico) | pin led : GP 14, OUTPUT · zet pin led aan (on) / uit (off) | Hetzelfde als pinMode() + digitalWrite() | led = Pin(14, Pin.OUT) · led.on() / led.off() |
| Tijd | wacht 1000 ms · wacht 0,5 seconden (Pico) | delay(1000); · delay(500); | time.sleep_ms(1000) · time.sleep(0.5) |
| Tijd | wacht 10 µs | delayMicroseconds(10); | time.sleep_us(10) |
| Tijd | milliseconden sinds start | millis() (unsigned long) | time.ticks_ms() |
| Voorwaarden | als … dan … anders als … anders … | if (…) { … } else if (…) { … } else { … } | if …: · elif …: · else: |
| Voorwaarden | ? = ? (≠, <, ≤, >, ≥) | == != < <= > >= | == != < <= > >= |
| Voorwaarden | ? en ? · ? of ? · niet ? | && · || · !x | and · or · not x |
| Lussen | herhaal 3 keer | for (int i = 0; i < 3; i++) { … } | for i in range(3): |
| Lussen | tel met i van 0 tot 5 in stappen van 1 | for (i = 0; i <= 5; i++) (5 inbegrepen, 6 rondes) | for i in range(0, 6): (6 niet inbegrepen) |
| Lussen | herhaal zolang | while (…) { … } | while …: |
| Lussen | verlaat de lus | break; | break |
| Variabelen | declareer geheel getal (int) delayTime = 60 | int delayTime = 60; | delayTime = 60 (geen type opgeschreven) |
| Variabelen | declareer decimaal getal (float) voltage = 0.0 | float voltage = 0.0; | voltage = 0.0 |
| Variabelen | zet x op 0 · verhoog x met 1 | x = 0; · x += 1; (of x++;) | x = 0 · x += 1 (x++ bestaat niet) |
| Variabelen | array 2 3 4 · item 0 van ledPins | int ledPins[] = {2, 3, 4}; · ledPins[0] | ledPins = [2, 3, 4] · ledPins[0] |
| Rekenen | 1 + 1 (ook −, ×, ÷) | + - * / · met twee ints 7 / 2 = 3 | + - * / · 7 / 2 = 3.5, gehele deling 7 // 2 = 3 |
| Rekenen | rest van 10 ÷ 3 | 10 % 3 | 10 % 3 |
| Rekenen | map x : 0 – 1023 → 0 – 255 | map(x, 0, 1023, 0, 255) | Niet ingebouwd; schrijf een arduino_map()-functie |
| Rekenen | begrens 50 laag 0 hoog 100 | constrain(50, 0, 100) | min(max(50, 0), 100) |
| Seriële poort | start serieel op 9600 baud | Serial.begin(9600); | Niet nodig, print() gaat via USB |
| Seriële poort | serieel afdrukken … nieuwe regel · geen regeleinde | Serial.println(x); · Serial.print(x); | print(x) · print(x, end="") |
| Analoog en PWM | analoog lezen A0 | analogRead(A0) → 0–1023 (0–4095 op de ESP32) | ADC(26).read_u16() → 0–65535 |
| Analoog en PWM | PWM schrijf 128 naar pin 9 · PWM led : GP 14, frequentie 1000 Hz (Pico) | analogWrite(9, 128); (0–255) | led = PWM(Pin(14)) · led.freq(1000) · led.duty_u16(32768) (0–65535) |
| Geluid | speel 440 Hz op pin 8 · stop geluid op pin 8 | tone(8, 440); · noTone(8); | Geen Pico-blok: bz = PWM(Pin(16)) · bz.freq(440) · bz.duty_u16(32768) · stoppen: bz.duty_u16(0) |
| Servo | koppel servo myServo aan pin 9 · draai servo myServo naar 90 graden | #include <Servo.h> · Servo myServo; · myServo.attach(9); · myServo.write(90); | Geen Pico-blok: s = PWM(Pin(16)) · s.freq(50) · s.duty_ns(1500000) (ongeveer 90°) |
| Sensor | lengte van HIGH-puls op pin 12 (µs) | pulseIn(12, HIGH) | machine.time_pulse_us(Pin(12, Pin.IN), 1) |
Sommige rijen lijken op het eerste gezicht één op één, maar vragen om aandacht. Bij "tel met i van 0 tot 5" is de 5 inbegrepen en draait de lus 6 keer; daarom gebruikt C++ <= in plaats van <, en heeft Python range(0, 6) nodig omdat range het eindgetal weglaat. Het deelblok is ook een valkuil: als je twee gehele getallen deelt, laat C++ de rest vallen en geeft 7 / 2 het antwoord 3, terwijl Python 3,5 geeft. Voor gehele deling zoals in C++ gebruik je in Python //. De map()-functie achter het blok "map x" is niet ingebouwd in MicroPython; in het voorbeeld hieronder doet een arduino_map()-functie van twee regels dezelfde berekening.
Hoe worden geneste blokken code?
Losse blokken kennen is niet genoeg; de echte vaardigheid is geneste blokken omzetten in één regel. Houd daarvoor twee vormen uit elkaar. Blokken die onder elkaar gestapeld zijn met een inkeping aan de rand, zijn opdrachten, en elk daarvan wordt een regel code. Ovale of puntige blokken die in de opening van een ander blok passen, zijn waarden; in code staan ze tussen haakjes, rechts van een gelijkteken of in een voorwaarde. De rijen hieronder komen uit het gratis project Frequentie instellen met buzzer: vier knoppen zetten de toon aan en uit en verhogen of verlagen de frequentie, die tussen 50 en 5000 Hz blijft.
| Blok (Frequentie instellen met buzzer) | C++-regel | Leesregel |
|---|---|---|
| zet state op 1 | state = 1; | Elk opdrachtblok dat onder een ander is gestapeld, is één regel en eindigt met een puntkomma. |
| als (lees pin btnOn = HIGH) dan … | if (digitalRead(btnOn) == HIGH) { … } | Een ovaal waardeblok komt tussen de haakjes; de =-vergelijking in het blok wordt == in code. |
| zet frequency op (frequency + 50) | frequency = frequency + 50; | Het binnenste blok wordt eerst uitgerekend en het resultaat wordt aan het buitenste blok doorgegeven. |
| zet frequency op (begrens frequency laag 50 hoog 5000) | frequency = constrain(frequency, 50, 5000); | De lege openingen van een blok zijn in code de argumenten, gescheiden door komma's. |
| speel frequency Hz op pin buzzerPin | tone(buzzerPin, frequency); | De volgorde in code ligt vast: eerst de pin, dan de waarde. De woordvolgorde van een blok kan per taal verschillen. |
| als (state = 1) dan … anders … | if (state == 1) { … } else { … } | Blokken in de "dan"-opening komen in de eerste { }, blokken in de "anders"-opening komen in else { }. |
Maak er een gewoonte van om bij het lezen van deze tabel eerst het binnenste blok te vertalen en dan naar buiten toe te werken. Bij "zet frequency op (begrens frequency laag 50 hoog 5000)" is het binnenste deel constrain(frequency, 50, 5000), en het buitenste zet-blok verpakt het als frequency = …. Een waardeblok kan niet in z'n eentje een regel zijn; als je het met een puntkomma laat staan, klaagt de compiler misschien niet, maar het resultaat wordt nergens opgeslagen.
Veelgemaakte fouten bij de overstap van blokken naar code
De blokeditor laat je de meeste van deze fouten niet maken; de vormen van de stukjes voorkomen dat ze op de verkeerde plek passen. Code neemt die bescherming weg, dus bijna iedereen loopt in de eerste weken tegen de fouten hieronder aan. De foutmeldingen zijn in het Engels, maar er zijn maar een paar patronen en na een paar keer herken je ze.
| Fout | Symptoom | Oplossing |
|---|---|---|
| Geen puntkomma aan het eind van een regel | "expected ';' before …"; de compiler wijst vaak naar de regel eronder | Sluit elk statement af met ;. Zet geen ; achter if-, for- en while-regels. |
| Ontbrekende of overbodige accolade | "expected '}' at end of input" of code die op de verkeerde plek wordt uitgevoerd | Elke { heeft een } nodig. Ctrl+T (automatisch opmaken) in de Arduino IDE herstelt het inspringen en laat een ontbrekende accolade makkelijk zien. |
| = schrijven in een voorwaarde | if (state = 1) is altijd waar en zet state ook op 1; SyntaxError in Python | Vergelijk met ==, wijs toe met =. De =-vergelijking in een blok is in code altijd ==. |
| Een decimaal getal in een int stoppen | int volt = 3.7; slaat 3 op; 5 / 2 geeft 2 | Gebruik float voor decimalen en schrijf één getal als 5.0 als je deelt. |
| De verkeerde waarde verwachten van digitalRead | if (digitalRead(2) == 5) wordt nooit uitgevoerd; de logica is omgekeerd bij een knop met pull-up | digitalRead geeft alleen HIGH (1) of LOW (0) terug. Met INPUT_PULLUP leest een ingedrukte knop LOW. |
| Hoofdletters en kleine letters door elkaar halen | 'digitalwrite' was not declared in this scope; NameError in Python | digitalWrite, pinMode en Serial moeten precies zo gespeld worden. In Python beginnen True en False met een hoofdletter. |
| Een telluslus één te kort vertalen | Een lus die in blokken 6 keer draait, draait in code 5 keer; de laatste led gaat nooit branden | "van 0 tot 5" is inclusief het einde: i <= 5 in C++, range(0, 6) in Python. |
| Verschoven inspringing in Python | IndentationError of een regel die buiten de lus valt | Begin elke regel onder while en if met dezelfde 4 spaties; meng geen tabs en spaties. |
| Python-tijd behandelen als milliseconden | time.sleep(500) wacht ruim 8 minuten | Schrijf time.sleep(0.5) of time.sleep_ms(500). |
| C++-gewoonten meenemen naar Python | SyntaxError door x++, && of een ; aan het eind van een regel | Python gebruikt x += 1, and, or; er is geen teken voor het einde van een regel. |
De blokken achter je laten: een methode in 4 stappen
Alles in één keer willen overstappen is vermoeiend. De vier stappen hieronder gaan in kleine stappen van lezen naar schrijven. Eén of twee projecten per stap zijn genoeg; je bent klaar voor de volgende stap als je de huidige kunt zonder naar de tabel te kijken.
- Lees naast elkaar. Open de blokken en de code van een project tegelijk en koppel met je vinger elk blok aan zijn regel in de code. Houd in deze stap de tabel naast je. Doel: elke regel code aan een blok kunnen koppelen.
- Verberg de blokken en raad. Kijk eerst naar de blokken, zet dan de blokweergave uit en schrijf de C++ voor die blokken op papier zonder naar de code te kijken. Vergelijk daarna met de echte code. Probeer het ook andersom: lees de code en raad de blokken.
- Verander een waarde in de code. Zet de code op je computer en verander slechts één getal: verhoog de wachttijd van 100 naar 500, of de drempel van 400 naar 600. Upload het en zie het verschil met eigen ogen. Krijg je een compileerfout, ga dan terug naar de fouttabel hierboven.
- Schrijf een nieuwe regel. Voeg een regel toe die niet in de blokken staat: een Serial.println() die de waarde naar de Serial Monitor schrijft, een tweede led of een if die met een knop werkt. Nu vertaal je geen blokken meer, maar schrijf je rechtstreeks code.
Bij elke stap hoort een les in de serie. Voor de eerste stap is de tabel van blok naar regel in een led laten knipperen met blokken een goed begin. Voor het werken met voorwaarden en lussen in stap twee en drie zie je het als-blok en lussen en variabelen. Ga je over op MicroPython op de Pico, dan behandelt van blokken naar MicroPython ook het instellen van Thonny. Wil je de overstap in de klas over meerdere weken spreiden, dan geeft het programmeerplan voor robotica van 8 weken je een kant-en-klare volgorde.
Blokken en code naast elkaar openen in de BlueGrays-app
Je gebruikt deze tabel het meest terwijl je heen en weer gaat tussen de blokken en de code van een echt project. De BlueGrays-app heeft een blokweergave voor meer dan 100 projecten; bij ruim 30 gratis projecten zijn de blokken ook open, en bij Premium-projecten worden de blokken met Premium ontgrendeld. Blokken zijn om te lezen: je kunt blokken in de app niet bewerken en blokken worden niet naar het board geüpload. Wat naar het board gaat, is altijd de echte code; die neem je mee met Kopiëren, of met Link kopiëren om hem op je computer te openen, en plak je in de Arduino IDE, of in Thonny voor de Pico.
- Tonen als blokken: zet deze schakelaar naast de broncode op een projectpagina aan en hetzelfde programma verschijnt als blokafbeelding in de taal van de app. Tik op de afbeelding om hem schermvullend te openen; de schakelaar uit en aan zetten is precies hoe je stap één en twee oefent.
- Blokken uitgelegd: met de blokweergave aan krijgt het tabblad "Code uitgelegd" deze naam. Het programma is verdeeld in stappen, elk met het deel dat het behandelt en een uitleg. De taak "Probeer het zelf" aan het eind is een kant-en-klare oefening voor stap vier.
- Codegids: elk van de 36 kaarten in het onderdeel Leren (18 Arduino C++, 18 MicroPython) toont zijn voorbeeld op drie manieren met de tabbladen Blokken, Arduino en MicroPython. Wil je een rij van de tabel uitgebreider zien, open dan de bijbehorende kaart.
- Projecten met blokken: deze optie onder Filter in Ontdekken › Projecten toont alleen projecten met een blokweergave, waardoor het kiezen van een project voor de overstap makkelijker wordt.
Hoe de codegids werkt, hebben we behandeld in het bericht over de codegids, en de onderdelen "Code uitgelegd" en "Probeer het zelf" in de gids over code uitgelegd. Voor elk commando afzonderlijk uitgelegd is de lijst met Arduino-commando's een goede aanvulling op deze tabel.
Eén programma op drie manieren: een nachtlampje dat dimt met het licht
Om de tabel in actie te zien, bouwen we een klein programma. Een LDR meet het licht; zolang de kamer licht is, blijft de led uit, en naarmate het donkerder wordt, gaat de led langzaam feller branden. Het programma gebruikt variabele-, analoog-lezen-, voorwaarde-, map-, PWM-, serieel- en wachtblokken, dus meer dan de helft van de tabel komt in dit ene voorbeeld voor. Het idee is gebaseerd op het gratis project Nachtlampje met LDR; daar is de led gewoon aan of uit, hier dimt PWM hem. Voor de bedrading van de LDR kun je ook het schakelschema van het project Lichtsterkte meten met een LDR bekijken.
| Aansluiting | Arduino Uno | Raspberry Pi Pico |
|---|---|---|
| LDR-pootje 1 | 5V | 3V3(OUT), fysieke pin 36 |
| LDR-pootje 2 + één uiteinde van de weerstand van 10 kΩ (middelpunt) | A0 | GP26 / ADC0, fysieke pin 31 |
| Ander uiteinde van de weerstand van 10 kΩ | GND | GND, fysieke pin 38 |
| Lange pootje van de led (via een weerstand van 220 Ω) | D9 (PWM-pin) | GP15, fysieke pin 20 |
| Korte pootje van de led | GND | GND, fysieke pin 18 |
| Lichtmeting / PWM-bereik | 0–1023 / 0–255 | 0–65535 / 0–65535 |
Eerst de blokversie. Met de labels uit de app bestaat het programma uit de onderstaande blokken; elk item komt overeen met een of meer regels van de C++-code die volgt:
- globale variabelen (bovenaan): declareer geheel getal (int) lightValue = 0 en declareer geheel getal (int) brightness = 0
- setup (eenmalig): start serieel op 9600 baud, zet daarna pin 9 als OUTPUT
- herhaal voor altijd: zet lightValue op (analoog lezen A0)
- als (lightValue < 400) dan: zet brightness op (map lightValue : 0 – 400 → 255 – 0); anders: zet brightness op 0
- PWM schrijf brightness naar pin 9
- serieel afdrukken "Light: " geen regeleinde, serieel afdrukken lightValue geen regeleinde, serieel afdrukken " PWM: " geen regeleinde, serieel afdrukken brightness nieuwe regel
- wacht 200 ms
1// ─────────────────────────────────────────
2// BlueGrays · bluegrays.com
3// Işığa göre kısılan gece lambası / Dimming night light
4// ─────────────────────────────────────────
5
6int lightValue = 0; // LDR okuması / LDR reading (0-1023)
7int brightness = 0; // LED parlaklığı / LED brightness (0-255)
8
9void setup() {
10 Serial.begin(9600); // Seri port 9600 baud / Serial at 9600 baud
11 pinMode(9, OUTPUT); // LED, PWM pini D9 / LED on PWM pin D9
12}
13
14void loop() {
15 lightValue = analogRead(A0); // Az ışık = küçük değer / Little light = small value
16
17 if (lightValue < 400) {
18 // Karanlık arttıkça LED parlar / The darker it gets, the brighter the LED
19 brightness = map(lightValue, 0, 400, 255, 0);
20 } else {
21 brightness = 0; // Oda aydınlık, LED kapalı / Room is bright, LED off
22 }
23
24 analogWrite(9, brightness); // PWM 0-255 / PWM 0-255
25
26 Serial.print("Light: ");
27 Serial.print(lightValue);
28 Serial.print(" PWM: ");
29 Serial.println(brightness);
30
31 delay(200); // 0,2 sn bekle / Wait 0.2 s
32}
331# ─────────────────────────────────────────
2# BlueGrays · bluegrays.com
3# Işığa göre kısılan gece lambası / Dimming night light
4# ─────────────────────────────────────────
5from machine import Pin, ADC, PWM
6import time
7
8ldr = ADC(26) # GP26 = ADC0 / GP26 = ADC0
9led = PWM(Pin(15)) # LED, GP15 / LED on GP15
10led.freq(1000) # PWM frekansı 1000 Hz / PWM frequency 1000 Hz
11
12THRESHOLD = 25600 # Uno'daki 400'ün karşılığı / Same as 400 on the Uno
13
14
15def arduino_map(x, in_min, in_max, out_min, out_max):
16 # Arduino map() ile aynı hesap / Same math as Arduino map()
17 return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
18
19
20while True:
21 light_value = ldr.read_u16() # 0-65535 / 0-65535
22
23 if light_value < THRESHOLD:
24 # Karanlık arttıkça LED parlar / The darker it gets, the brighter the LED
25 brightness = arduino_map(light_value, 0, THRESHOLD, 65535, 0)
26 else:
27 brightness = 0 # Oda aydınlık, LED kapalı / Room is bright, LED off
28
29 led.duty_u16(brightness) # PWM 0-65535 / PWM 0-65535
30
31 print("Light:", light_value, " PWM:", brightness)
32
33 time.sleep(0.2) # 0,2 sn bekle / Wait 0.2 s
34Vergelijk de twee programma's regel voor regel en elk verschil met de tabel komt naar voren. setup() in C++ wordt de regels vóór while True in Python, en Serial.begin() verdwijnt. analogRead(A0) wordt ADC(26).read_u16() en het bereik groeit van 0–1023 naar 0–65535, daarom is de drempel 25600 in plaats van 400. In plaats van analogWrite(9, …) wordt eerst een PWM-object gemaakt en de helderheid ingesteld met duty_u16() tussen 0 en 65535. Omdat map() niet ingebouwd is, wordt een arduino_map()-functie geschreven; de gehele deling // erin komt overeen met de gehele deling in C++. Eén print() vervangt vier afzonderlijke Serial.print()-aanroepen en delay(200) wordt time.sleep(0.2).
Overstappen van programmeren met blokken naar Arduino C++ draait minder om iets nieuws uit je hoofd leren en meer om het herkennen van de geschreven vorm van blokken die je al kent. Houd deze tabel naast je, lees bij elk project eerst naast elkaar, verberg daarna de blokken en schrijf het zelf. Wil je deze rijen in echte projecten zien, open dan een project met blokweergave in de BlueGrays-app en schakel met Tonen als blokken tussen de twee vormen van hetzelfde programma.
Veelgestelde vragen
Wat moet ik leren na programmeren met blokken: C++ of Python?
Kies op basis van het board dat je hebt. De meeste projecten voor Arduino Uno en ESP32 zijn in Arduino C++ geschreven, terwijl MicroPython gebruikelijk is op de Raspberry Pi Pico. De logica van de blokken is in beide hetzelfde, dus als je de ene kent, kost het veel minder tijd om over te stappen op de andere.
Hoe lang duurt het om over te stappen van blokken naar Arduino-code?
Dat verschilt per persoon, maar wie een paar projecten per week doet, kan meestal binnen een paar weken korte programma's lezen en kleine aanpassingen maken. Eerst code naast de blokken lezen, dan één waarde veranderen en ten slotte nieuwe regels toevoegen maakt de overstap makkelijker.
Kan ik een Arduino Uno met Python programmeren?
De Arduino Uno kan geen MicroPython draaien; hij wordt in C++ geprogrammeerd met de Arduino IDE. Voor MicroPython heb je een krachtiger board nodig, zoals de Raspberry Pi Pico. Je kunt wel commando's naar een Uno sturen via de seriële poort vanuit een Python-programma op je computer.
Kan ik blokken in BlueGrays bewerken en naar het board uploaden?
Nee. De blokken in BlueGrays zijn bedoeld om de code te lezen en te begrijpen; je kunt blokken in de app niet bewerken en ze worden niet naar het board geüpload. Wat je uploadt, is altijd de echte code van het project, met de Arduino IDE of Thonny.
Is een blokprogramma echte code?
Blokken zijn een visuele vorm van echte code; elk blok komt overeen met een of meer regels code. In BlueGrays-projecten met een blokweergave beschrijven de blokken en de Arduino C++- of MicroPython-code die je uploadt hetzelfde programma.
Waarom geeft digitalRead 1 of 0 terug, en is HIGH hetzelfde als 1?
Ja, in Arduino is HIGH gelijk aan 1 en LOW gelijk aan 0, en digitalRead geeft alleen een van die twee waarden terug. Een knop die met INPUT_PULLUP is aangesloten, leest LOW terwijl hij ingedrukt is en HIGH als hij losgelaten is. In MicroPython geeft pin.value() ook 1 of 0.
Projecten om hierna te bouwen
Alle projecten bekijken
Frequentie instellen met een buzzer
Met vier knoppen bestuur je het geluid van een buzzer: één start het geluid, één stopt het en de andere twee maken het hoger of lager.

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

Lichtsterkte meten met een LDR
Wil je zien hoe licht je kamer is, als getal? De LDR, een klein onderdeel dat op licht reageert, meet het licht om je heen en de Arduino schrijft de waarde elke halve seconde naar je computerscherm.

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.

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.

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.

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

