Basis · 11 min leestijd

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.

Wil je de blokken stap voor stap leren, dan is er de serie Van blokken naar code: wat programmeren met blokken is, een led laten knipperen met blokken, het als-blok, lussen en variabelen en sensoren uitlezen met blokken en MicroPython. Dit bericht bundelt al die lessen in één tabel.
Blokken van het project Frequentie instellen met buzzer: globale variabelen, vier knoppen-pins als INPUT gezet in setup, if-blokken in herhaal voor altijd, begrens- en speel-geluidblokken
Blokken van het project Frequentie instellen met buzzer. Declareren, als INPUT zetten, pin lezen, zetten, begrenzen, geluid spelen en stoppen uit de tabel komen allemaal in dit ene programma voor.

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 (·).

GroepBlok (label in de app)Arduino C++MicroPython (Pico)
Structuursetup (eenmalig)void setup() { … }De regels vóór while True:
Structuurherhaal voor altijdvoid loop() { … }while True: (inhoud 4 spaties ingesprongen)
Structuurglobale variabelen (bovenaan)Bovenaan het bestand, vóór setup()De eerste regels na de imports
Structuurom blinkTwicevoid blinkTwice() { … } · aanroep: blinkTwice();def blinkTwice(): · aanroep: blinkTwice()
Pinszet pin 13 als OUTPUTpinMode(13, OUTPUT);led = Pin(15, Pin.OUT)
Pinszet pin 2 als INPUT_PULLUPpinMode(2, INPUT_PULLUP);btn = Pin(14, Pin.IN, Pin.PULL_UP)
Pinsschrijf HIGH naar pin 13 · schrijf LOW naar pin 13digitalWrite(13, HIGH); · digitalWrite(13, LOW);led.value(1) · led.value(0)
Pinslees pin 2digitalRead(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()
Tijdwacht 1000 ms · wacht 0,5 seconden (Pico)delay(1000); · delay(500);time.sleep_ms(1000) · time.sleep(0.5)
Tijdwacht 10 µsdelayMicroseconds(10);time.sleep_us(10)
Tijdmilliseconden sinds startmillis() (unsigned long)time.ticks_ms()
Voorwaardenals … dan … anders als … anders …if (…) { … } else if (…) { … } else { … }if …: · elif …: · else:
Voorwaarden? = ? (≠, <, ≤, >, ≥)== != < <= > >=== != < <= > >=
Voorwaarden? en ? · ? of ? · niet ?&& · || · !xand · or · not x
Lussenherhaal 3 keerfor (int i = 0; i < 3; i++) { … }for i in range(3):
Lussentel met i van 0 tot 5 in stappen van 1for (i = 0; i <= 5; i++) (5 inbegrepen, 6 rondes)for i in range(0, 6): (6 niet inbegrepen)
Lussenherhaal zolangwhile (…) { … }while …:
Lussenverlaat de lusbreak;break
Variabelendeclareer geheel getal (int) delayTime = 60int delayTime = 60;delayTime = 60 (geen type opgeschreven)
Variabelendeclareer decimaal getal (float) voltage = 0.0float voltage = 0.0;voltage = 0.0
Variabelenzet x op 0 · verhoog x met 1x = 0; · x += 1; (of x++;)x = 0 · x += 1 (x++ bestaat niet)
Variabelenarray 2 3 4 · item 0 van ledPinsint ledPins[] = {2, 3, 4}; · ledPins[0]ledPins = [2, 3, 4] · ledPins[0]
Rekenen1 + 1 (ook −, ×, ÷)+ - * / · met twee ints 7 / 2 = 3+ - * / · 7 / 2 = 3.5, gehele deling 7 // 2 = 3
Rekenenrest van 10 ÷ 310 % 310 % 3
Rekenenmap x : 0 – 1023 → 0 – 255map(x, 0, 1023, 0, 255)Niet ingebouwd; schrijf een arduino_map()-functie
Rekenenbegrens 50 laag 0 hoog 100constrain(50, 0, 100)min(max(50, 0), 100)
Seriële poortstart serieel op 9600 baudSerial.begin(9600);Niet nodig, print() gaat via USB
Seriële poortserieel afdrukken … nieuwe regel · geen regeleindeSerial.println(x); · Serial.print(x);print(x) · print(x, end="")
Analoog en PWManaloog lezen A0analogRead(A0) → 0–1023 (0–4095 op de ESP32)ADC(26).read_u16() → 0–65535
Analoog en PWMPWM 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)
Geluidspeel 440 Hz op pin 8 · stop geluid op pin 8tone(8, 440); · noTone(8);Geen Pico-blok: bz = PWM(Pin(16)) · bz.freq(440) · bz.duty_u16(32768) · stoppen: bz.duty_u16(0)
Servokoppel 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°)
Sensorlengte 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.

Reken drempelwaarden en spanningen opnieuw uit als je van Arduino naar de Pico overstapt. Een lichtdrempel van 400 op de Uno is ongeveer 25600 op de Pico (400 × 65535 / 1023). De Pico werkt op 3,3 V: voed spanningsdelers van sensoren vanaf de pin 3V3(OUT) en geef nooit 5 V op GPIO- of ADC-pins.

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++-regelLeesregel
zet state op 1state = 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 buzzerPintone(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.

FoutSymptoomOplossing
Geen puntkomma aan het eind van een regel"expected ';' before …"; de compiler wijst vaak naar de regel eronderSluit 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 uitgevoerdElke { heeft een } nodig. Ctrl+T (automatisch opmaken) in de Arduino IDE herstelt het inspringen en laat een ontbrekende accolade makkelijk zien.
= schrijven in een voorwaardeif (state = 1) is altijd waar en zet state ook op 1; SyntaxError in PythonVergelijk met ==, wijs toe met =. De =-vergelijking in een blok is in code altijd ==.
Een decimaal getal in een int stoppenint volt = 3.7; slaat 3 op; 5 / 2 geeft 2Gebruik float voor decimalen en schrijf één getal als 5.0 als je deelt.
De verkeerde waarde verwachten van digitalReadif (digitalRead(2) == 5) wordt nooit uitgevoerd; de logica is omgekeerd bij een knop met pull-updigitalRead 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 PythondigitalWrite, pinMode en Serial moeten precies zo gespeld worden. In Python beginnen True en False met een hoofdletter.
Een telluslus één te kort vertalenEen 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 PythonIndentationError of een regel die buiten de lus valtBegin elke regel onder while en if met dezelfde 4 spaties; meng geen tabs en spaties.
Python-tijd behandelen als millisecondentime.sleep(500) wacht ruim 8 minutenSchrijf time.sleep(0.5) of time.sleep_ms(500).
C++-gewoonten meenemen naar PythonSyntaxError door x++, && of een ; aan het eind van een regelPython gebruikt x += 1, and, or; er is geen teken voor het einde van een regel.
Als de compiler naar een regel wijst, kijk dan altijd ook naar de regel erboven. Een ontbrekende puntkomma of een niet gesloten haakje wordt vaak één regel onder het echte probleem opgemerkt. Als er meerdere fouten tegelijk staan, los dan alleen de eerste op en compileer opnieuw; de rest zijn vaak echo's van de eerste.

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.

AansluitingArduino UnoRaspberry Pi Pico
LDR-pootje 15V3V3(OUT), fysieke pin 36
LDR-pootje 2 + één uiteinde van de weerstand van 10 kΩ (middelpunt)A0GP26 / ADC0, fysieke pin 31
Ander uiteinde van de weerstand van 10 kΩGNDGND, fysieke pin 38
Lange pootje van de led (via een weerstand van 220 Ω)D9 (PWM-pin)GP15, fysieke pin 20
Korte pootje van de ledGNDGND, fysieke pin 18
Lichtmeting / PWM-bereik0–1023 / 0–2550–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:

  1. globale variabelen (bovenaan): declareer geheel getal (int) lightValue = 0 en declareer geheel getal (int) brightness = 0
  2. setup (eenmalig): start serieel op 9600 baud, zet daarna pin 9 als OUTPUT
  3. herhaal voor altijd: zet lightValue op (analoog lezen A0)
  4. als (lightValue < 400) dan: zet brightness op (map lightValue : 0 – 400 → 255 – 0); anders: zet brightness op 0
  5. PWM schrijf brightness naar pin 9
  6. serieel afdrukken "Light: " geen regeleinde, serieel afdrukken lightValue geen regeleinde, serieel afdrukken " PWM: " geen regeleinde, serieel afdrukken brightness nieuwe regel
  7. wacht 200 ms
C++ (Arduino IDE)
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}
33
MicroPython
1# ─────────────────────────────────────────
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
34

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

Probeer stap drie meteen met dit voorbeeld: verhoog op de Uno de drempel van 400 naar 600 zodat de led eerder gaat gloeien. Om dezelfde wijziging op de Pico te doen, zet je THRESHOLD op ongeveer 38400. Houd de waarde Light in de Serial Monitor (9600 baud) of in de shell van Thonny in de gaten om de juiste drempel voor jouw kamer te vinden.

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.

Alle projecten bekijken
Frequentie instellen met een buzzer
AR-14Gemiddeld

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.

4.6(69)
120
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
Lichtsterkte meten met een LDR
AR-11Beginner

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.

4.6(83)
143
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)
252
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-looplicht met instelbare snelheid
AR-7Gemiddeld

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.

4.6(72)
148
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
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