Gidsen · 19 min leestijd

mBlock Arduino-tutorial: installatie, Live- en Upload-modus en blokken

mBlock Arduino-tutorial: installeer mBlock 5, voeg de Arduino Uno en de firmware toe, Live- vs Upload-modus, led-, knop- en sensorblokken, Arduino C-code, 9 activiteiten.

Een Arduino programmeren met mBlock is een van de makkelijkste manieren om een Arduino Uno een led te laten knipperen of een knop of sensor uit te lezen zonder ook maar één regel code te schrijven. mBlock 5, gratis ontwikkeld door Makeblock, is een omgeving voor programmeren met blokken, gebouwd op Scratch 3.0: je klikt kleurrijke blokken als puzzelstukjes aan elkaar en mBlock zet ze op de achtergrond om in Arduino C-code, compileert die en uploadt hem naar je board. Je kunt de blokken ook direct op het board laten draaien en laten samenwerken met figuren op het podium. Daarom is het een van de populairste tools in robotprogrammeerlessen op school, bij projecten voor de wetenschapsbeurs en als eerste stap in Arduino.

In deze gids leer je stap voor stap hoe je mBlock op je computer installeert of in de browser gebruikt, hoe je een Arduino Uno als apparaat toevoegt en aansluit, hoe je de firmware voor de Live-modus uploadt, wat het verschil is tussen de Live-modus en de Upload-modus, welke led-, knop- en sensorblokken er zijn, in welke Arduino C-regels de blokken worden omgezet, negen activiteiten voor in de klas, hoe je doorstapt naar de Arduino IDE en hoe je de meest voorkomende verbindingsproblemen oplost.

Arduino Uno R3-board geprogrammeerd met mBlock
De Arduino Uno is het board dat het soepelst met mBlock werkt; dankzij de ingebouwde L-led op pin 13 heb je voor je eerste tests geen extra onderdelen nodig.

Wat is mBlock en hoe werkt het met Arduino?

mBlock is een programmeeromgeving die bovenop Scratch 3.0 is gebouwd, dat bij MIT is ontwikkeld. Het grootste verschil met Scratch is dat je naast de figuren op het scherm (sprites) ook echte hardware kunt programmeren. De interface heeft twee aparte tabs: op de tab Sprites programmeer je de figuren op het podium en op de tab Devices programmeer je boards zoals Arduino, micro:bit of Makeblock-robots. Als je een apparaat selecteert, komen er categorieën voor dat board bij in het blokkenpalet; voor de Arduino Uno zijn dat de pin- en seriëlepoortblokken. In de Upload-modus wordt je blokkenscript vertaald naar Arduino C, gecompileerd tot machinecode en via USB naar het flashgeheugen van het board geschreven. mBlock doet dus hetzelfde werk als de Arduino IDE, maar dan via een blokkeninterface, en omdat het de code laat zien die het genereert, maakt het ook de overstap naar tekstcode makkelijker.

KenmerkmBlock 5
OntwikkelaarMakeblock
Gebaseerd opScratch 3.0 (opent Scratch- en mBlock 3-projecten)
PrijsGratis
VersiesDesktop voor Windows en macOS, browser (Chrome of Edge), app voor Android en iOS
Arduino-boardsUno, Nano, Nano (old), Mega 2560; Leonardo, Micro en Yun in de desktopversie of via mLink
TeksttaalArduino C op Arduino-boards, Python op Makeblock-boards en op het podium
Projectbestand.mblock
InterfacetaalTientallen talen, waaronder Nederlands

mBlock installeren: desktop- en webversie

  1. Ga in je browser naar mblock.cc en download op de Download-pagina de mBlock 5-desktopversie voor jouw besturingssysteem. Op het moment van schrijven is de actuele versie V5.6; die ondersteunt 64-bits Windows 7 en nieuwer en macOS 10.12 en nieuwer, met een apart installatieprogramma voor Macs met een Apple M-chip.
  2. Voer onder Windows het installatieprogramma uit en volg de wizard. Als tijdens de installatie wordt aangeboden om het CH340-stuurprogramma te installeren, accepteer dat dan: de meeste Arduino-klonen gebruiken deze USB-naar-serieel-chip en zonder het stuurprogramma verschijnt de poort niet.
  3. Als het installatieprogramma onder macOS niet opent, klik dan met de rechtermuisknop op het bestand en kies Open, of gebruik de knop Open Anyway onder Privacy & Security in de Systeeminstellingen.
  4. Open mBlock en kies je taal via het wereldbolicoon in het bovenste menu. Vanaf dan verschijnen de menu's en blokkennamen in die taal.
  5. Op schoolcomputers waarop je geen software kunt installeren, open je ide.mblock.cc in de browser; gebruik voor de Arduino-verbinding een actuele versie van Chrome of Edge.

Lange tijd maakte de webversie verbinding met boards via een klein hulpprogramma genaamd mLink. In nieuwere versies is de standaardmethode een directe verbinding via de seriëlepoortfunctie van de browser: als je op verbinden klikt, opent de browser een venster, kies je de poort van de Arduino en ben je verbonden zonder iets extra's te installeren. Dit werkt met de Uno, Nano, Nano (old) en Mega 2560; boards die USB anders gebruiken, zoals de Leonardo, Micro en Yun, hebben nog steeds mLink nodig. Zolang mLink draait, staat er een klein pandaicoon in de taakbalk. Houd de desktop- en de webversie, of twee mBlock-tabs, niet tegelijk open; beide proberen dezelfde poort te gebruiken en dan mislukt de verbinding.

KenmerkDesktopversieWebversie
InstallatieVereist (Windows, macOS)Niet nodig, opent in de browser
BrowservereisteGeenChrome of Edge (voor ondersteuning van de seriële poort)
Arduino-verbindingUSB-kabel en stuurprogramma zijn genoegDirecte verbinding of mLink
Leonardo, Micro, YunOndersteundAlleen met mLink
Chromebook en LinuxGeen desktopversieWerkt met Chrome
Projecten opslaan.mblock-bestand op de computerIn je account of gedownload naar de computer
Geschikt voor schoolWerkt soepeler op trage of beperkte netwerkenHandig op computers zonder installatierechten

Een apparaat toevoegen: de Arduino Uno met mBlock verbinden

  1. Sluit de Arduino met een USB-kabel aan op de computer; de ON-led (voeding) op het board moet gaan branden.
  2. Ga in mBlock naar de tab Devices onder het podium. Verwijder het Makeblock-apparaat dat standaard aanwezig is (Codey Rocky of CyberPi, afhankelijk van de versie) met het kruisje in de hoek.
  3. Klik op + Add, typ "Arduino" in het zoekvak van de Device Library die opent, selecteer Arduino Uno en klik op OK. Als je op de ster linksboven op het board klikt, staat het de volgende keer dat mBlock opent meteen klaar.
  4. Klik op Connect. Kies op de tab USB van het venster dat opent de poort die mBlock heeft gevonden: onder Windows zie je een naam zoals COM3 of COM4, onder macOS iets als /dev/cu.usbmodem… of, bij boards met een CH340, /dev/cu.wchusbserial…. Staat de poort er niet bij, vink dan Show all connectable devices aan.
  5. Klik nogmaals op Connect. Als de melding "Device connected" verschijnt, ben je klaar; de Arduino-specifieke pin- en seriëlepoortblokken verschijnen in het blokkenpalet.

Het juiste apparaat kiezen is het halve werk. Of het nu een origineel of een kloon is, kies Arduino Uno voor een Uno en Arduino Mega2560 voor een Mega. De meeste goedkope Arduino Nano-klonen hebben de oude bootloader; bij deze boards mislukt het uploaden met Arduino Nano, terwijl de optie Arduino Nano (old) wel werkt. Nieuwere boards met een andere processor, zoals de Arduino Uno R4, kun je niet programmeren met het Uno-apparaat van mBlock; gebruik daarvoor direct de Arduino IDE. Als je nog niet hebt besloten welk board je koopt, lees dan Welke Arduino moet ik kopen? en bekijk voor de pinindeling van de Nano de gids Arduino Nano-pinout.

Arduino Nano-board gebruikt met mBlock
Arduino Nano-klonen hebben meestal een CH340 USB-chip en de oude bootloader; in mBlock upload je ernaar met de optie Arduino Nano (old).
Het meest voorkomende verbindingsprobleem is de verkeerde kabel. Sommige USB-kabels die van telefoonladers zijn overgebleven, voeren alleen stroom en hebben geen datalijnen: het lampje van het board gaat branden, maar de computer ziet de poort nooit. Als je de kabel in een telefoon kunt steken en bestanden kunt overzetten, is het een datakabel. Steek het board bovendien rechtstreeks in de USB-poort van de computer en niet in een USB-hub.

Live-modus vs Upload-modus: wat is het verschil?

mBlock biedt twee modi om apparaten te programmeren; je schakelt ertussen met de schakelaar op de tab Devices. In de Live-modus draait het programma eigenlijk op de computer: mBlock leest elk blok om de beurt en stuurt commando's zoals "zet pin 13 aan" of "lees A0 en stuur het resultaat terug" via USB naar de Arduino. Daarvoor heeft de Arduino speciale firmware nodig die deze commando's begrijpt. Je ziet het resultaat direct, je kunt sensorwaarden op het podium volgen en de Arduino met de sprites laten communiceren, maar zodra je de USB-kabel loskoppelt of mBlock sluit, stopt het programma. In de Upload-modus worden de blokken vertaald naar Arduino C, gecompileerd en permanent naar het board geschreven; ook met losgekoppelde kabel blijft het programma draaien op een batterij of adapter. In deze modus moet je programma onder het hat-blok when Arduino Uno starts up staan; podiumgebeurtenissen zoals de groene vlag worden niet naar het board overgebracht.

KenmerkLive-modusUpload-modus
Waar draait het programma?Op de computer, commando's gaan via USBOp de eigen processor van de Arduino
StartblokGebeurtenissen zoals when green flag clicked of when a key is pressedwhen Arduino Uno starts up
USB-kabelMoet aangesloten blijvenAlleen nodig tijdens het uploaden
Software op de ArduinomBlock-firmwareJe gecompileerde programma
TimingLangzamer en onregelmatig, omdat elk commando heen en weer over USB gaatOp de milliseconde nauwkeurig, zelfs op de microseconde
Interactie met spritesDirect met variabele- en broadcastblokkenAlleen met de extensie Upload Mode Broadcast op apparaten die dit ondersteunen
Het best voorTesten, debuggen, podiumspellenRobots, alarmen, afgewerkte projecten op batterijen

De firmware uploaden: de Arduino klaarmaken voor de Live-modus

  1. Verbind de Arduino (Connect) en zet de modusschakelaar op Live.
  2. Als het board de mBlock-firmware niet heeft, biedt mBlock meestal aan om die bij te werken. Doet het dat niet, kies dan Update Firmware in het menu Setting naast de verbindingsknoppen en start de update in het venster dat opent.
  3. Tijdens het uploaden knipperen de TX- en RX-leds van het board snel; koppel de kabel niet los en sluit mBlock niet af totdat de voortgangsbalk klaar is.
  4. Om het te testen sleep je het blok set digital pin (13) output as (high) uit de pinblokken naar het scriptgebied en klik je er één keer op. Als de L-led op het board meteen gaat branden, werkt de Live-modus; klik op hetzelfde blok met de optie (low) en de led gaat uit.
De firmware van de Live-modus en je eigen programma delen hetzelfde flashgeheugen. Als je in de Upload-modus een programma uploadt (of een sketch vanuit de Arduino IDE verstuurt), wordt de firmware gewist. Ga je later terug naar de Live-modus, dan reageren de blokken niet; upload in dat geval gewoon opnieuw de firmware. Als je in de klas vaak tussen de twee modi wisselt, schrijf deze stap dan op het whiteboard zodat niemand hem vergeet.

Basisblokken voor Arduino: leds, knoppen en sensoren

Zodra de Arduino Uno is toegevoegd, krijgt het blokkenpalet board-specifieke categorieën voor pins en de seriële poort naast de categorieën Events, Control, Operators, Variables en My Blocks die je van Scratch kent. In de tabel hieronder staan de blokken met hun Engelse namen en wat ze doen. Blokkennamen kunnen per versie een beetje verschillen; als je met de rechtermuisknop op een blok klikt en Help kiest, toont mBlock een beschrijving ervan. Op de Uno werkt PWM alleen op pin 3, 5, 6, 9, 10 en 11; de volledige pinindeling vind je in de tool Pinout.

Blok (Engelse naam)Wat doet het?Voorbeeldgebruik
when Arduino Uno starts upHat-blok waar het programma in de Upload-modus begintElk programma dat naar het board wordt geüpload
set digital pin (13) output as (high)Zet de pin op HIGH (5 V) of LOW (0 V)Led, actieve buzzer, relais
read digital pin (2)Leest het niveau op de pin als waar of onwaarKnop, PIR, infrarood obstakelsensor
read analog pin (A) (0)Zet de spanning op pin A0–A5 om in een getal van 0 tot 1023LDR, potmeter, bodemvochtsensor
set pwm pin (5) output as (128)Maakt een PWM-signaal van 0 tot 255Helderheid van een led, snelheid van een gelijkstroommotor
set servo pin (9) angle as (90)Beweegt de servo naar een hoek tussen 0 en 180 gradenSG90-slagboom, robotarm
play pin (8) with note (C4) for (0.25) beatSpeelt een noot af op een passieve buzzerMelodie, deurbel
forever / repeat (10) / if … then … elseLus- en voorwaardeblokkenContinu controleren, tellen, beslissingen
wait (1) secondsPauzeert het programma voor de opgegeven tijdKnipperen, stoplicht
LED
LED
Drukknop
Drukknop
LDR-lichtsensor
LDR-lichtsensor
Potmeter
Potmeter
SG90 servo motor
SG90 servo motor
Buzzer
Buzzer
HC-SR04-afstandssensor
HC-SR04-afstandssensor

Bedradingstabel: één lespakket voor alle activiteiten

Elke week de schakeling opnieuw opbouwen kost lestijd. Als je de onderstaande bedrading één keer op een breadboard bouwt, kun je alle negen activiteiten doen zonder de kabels aan te raken. De weerstand voor de led controleer je met de ledweerstandsrekenmachine en de spanning die de LDR-deler geeft met de tool spanningsdeler. Als je deze onderdelen voor het eerst gebruikt, leggen de artikelen over de led, de knop, de LDR en de servomotor elke aansluiting uitgebreid uit.

OnderdeelArduino UnoESP32Raspberry Pi PicoOpmerking
Led + weerstand van 220 ΩD5GPIO 18GP14Lange pootje (anode) naar de pin, korte pootje naar GND
Knop + pull-downweerstand van 10 kΩD2GPIO 4GP2Andere kant van de knop naar 5V op de Uno, naar 3V3 op de ESP32 en Pico
LDR + weerstand van 10 kΩA0GPIO 34GP26 (ADC0)LDR tussen voeding en pin, weerstand tussen pin en GND
Potmeter (middelste pin)A1GPIO 35GP27 (ADC1)Buitenste pins naar voeding en GND
SG90-servo (signaal)D9GPIO 13GP16Rode draad naar 5 V (VIN op de ESP32, VBUS op de Pico), bruine naar GND
Passieve buzzerD8GPIO 25GP15Andere pin naar GND
HC-SR04 Trig / EchoD11 / D12GPIO 26 / 27GP17 / GP18Breng op de ESP32 en Pico de Echo-lijn met een spanningsdeler terug naar 3,3 V
Op de Arduino Uno gebruikt de Servo-bibliotheek Timer1, dus zolang een servo draait, werkt PWM (analogWrite) niet op pin D9 en D10; de functie tone() die noten op de buzzer afspeelt, gebruikt Timer2 en verstoort PWM op D3 en D11. Daarom zet de tabel de led op D5. De ESP32 en Pico werken op 3,3 V: voed knoppen of sensoren die op hun pins zijn aangesloten nooit met 5 V.

Eerste programma: een led laten knipperen in de Upload-modus

  1. Zet de modusschakelaar op Upload.
  2. Sleep het blok when Arduino Uno starts up uit de categorie Events naar het scriptgebied.
  3. Zet daaronder een blok forever uit de categorie Control.
  4. Plaats in het forever-blok, in deze volgorde, set digital pin (13) output as (high), wait (1) seconds, set digital pin (13) output as (low) en nog een wait (1) seconds.
  5. Klik op Upload. mBlock compileert de code en stuurt hem naar het board; na een paar seconden meldt een bericht dat het uploaden klaar is.
  6. De L-led op het board begint één keer per seconde te knipperen. Als je de USB-kabel losmaakt en het board voedt met een powerbank of een adapter van 7–12 V, blijft het programma draaien; de voedingsopties behandelen we in een Arduino op batterijen laten draaien.

Hoe worden blokken Arduino C-code?

Klik in de Upload-modus op de knop Arduino C aan de rechterrand (het icoon met de punthaak) en mBlock toont in een paneel de code die bij je blokken hoort. Elke wijziging in de blokken werkt de code direct bij; het is de makkelijkste manier om te leren welk blok welke regel oplevert. Als je aan het Blink-programma hierboven een variabele sayac (teller) toevoegt en die bij elke ronde met 1 ophoogt, ziet de gegenereerde code er ongeveer zo uit. We hebben de commentaarregels toegevoegd; spaties en de plaats van sommige regels, zoals pinMode, kunnen per versie een beetje verschillen.

C++ (Arduino IDE)
1// generated by mBlock5 for <your product>
2// codes make you happy
3// mBlock'un ürettiği kodun yapısı: Blink + sayaç / Structure of mBlock-generated code: Blink + counter
4
5#include <Arduino.h>
6#include <Wire.h>
7#include <SoftwareSerial.h>
8
9float sayac = 0;               // mBlock değişkenleri float olur / mBlock variables become float
10
11void _loop();                  // ön bildirim, Arduino IDE de ekler / forward declaration, the Arduino IDE adds it too
12
13void _delay(float seconds) {   // "wait (1) seconds" bloğu / the "wait (1) seconds" block
14  long endTime = millis() + seconds * 1000;
15  while (millis() < endTime) _loop();
16}
17
18void setup() {                 // "when Arduino Uno starts up" altındaki bloklar / blocks under "when Arduino Uno starts up"
19  pinMode(13, OUTPUT);
20  while (1) {                  // "forever" bloğu / the "forever" block
21    digitalWrite(13, 1);       // pin 13 HIGH: dahili L LED'i yanar / pin 13 HIGH: the built-in L LED turns on
22    _delay(1);
23    digitalWrite(13, 0);       // pin 13 LOW: LED söner / pin 13 LOW: the LED turns off
24    _delay(1);
25    sayac += 1;                // "change sayac by 1" bloğu / the "change sayac by 1" block
26    _loop();
27  }
28}
29
30void _loop() {                 // uzantıların sürekli çalışan kodu buraya eklenir / extensions add their recurring code here
31}
32
33void loop() {
34  _loop();
35}

In deze code zijn vier dingen opvallend. Ten eerste wordt het blok forever niet de functie loop() van Arduino, maar een eindeloze while(1)-lus binnen setup(); loop() roept alleen de functie _loop() aan. Ten tweede gebruikt het blok wait een functie _delay() in plaats van delay(); tijdens het wachten blijft deze functie _loop() aanroepen, zodat het werk dat sommige extensies op de achtergrond moeten doen niet wordt opgehouden. Ten derde wordt elke variabele die je in mBlock maakt gedeclareerd als float (een decimaal getal); op de Uno neemt elke variabele 4 bytes RAM in en kan dat kleine afrondingsfouten geven bij gelijkheidsvergelijkingen. Een variabele die je in stappen van 0,1 ophoogt, is na tien stappen bijvoorbeeld misschien niet precies 1, dus een vergelijking met "groter dan" of "kleiner dan" is veiliger dan "is gelijk aan". Ten vierde worden de bibliotheken Wire en SoftwareSerial bovenaan meestal meegenomen, ook als je ze niet gebruikt; het programma werkt dan nog steeds, maar kan wat meer ruimte innemen dan een met de hand geschreven versie.

BlokArduino C-equivalent
when Arduino Uno starts upCode binnen void setup() { … }
foreverwhile(1) { … _loop(); }
repeat (10)for (int count = 0; count < 10; count++) { … }
wait (1) seconds_delay(1);
wait until (condition)while (!(condition)) { _loop(); }
if (condition) then … else …if (condition) { … } else { … }
set digital pin (13) output as (high)pinMode(13, OUTPUT); digitalWrite(13, 1);
read digital pin (2)digitalRead(2)
read analog pin (A) (0)analogRead(A0)
set pwm pin (5) output as (128)analogWrite(5, 128);
set servo pin (9) angle as (90)Servo-bibliotheek: attach(9) en write(90)
set [sayac] to (0) / change [sayac] by (1)sayac = 0; / sayac += 1;

Voorbeeldactiviteiten voor lessen robotprogrammeren

De negen activiteiten hieronder zijn van makkelijk naar moeilijk geordend voor lessen van 40 minuten en ze werken allemaal met het ene bedradingspakket hierboven. Het is een goede aanpak om elke activiteit in de Live-modus te starten: leerlingen klikken op een blok en zien direct het resultaat, volgen sensorwaarden op het podium en vinden zelf hun fouten. Zodra het programma werkt zoals bedoeld, leert het overzetten van dezelfde blokken naar de Upload-modus en ze permanent op het board schrijven het idee van "een apparaat dat zonder computer werkt". De programmeerconcepten achter deze activiteiten vind je ook in tekstcode in het artikel Basis van Arduino-programmeren.

LesActiviteitGebruikte blokkenGeleerd concept
1Knipperend signaallicht (D13 of D5)set digital pin, wait, foreverVolgorde, oneindige lus
2Stoplicht (drie leds op D5, D6 en D7)set digital pin, waitTiming, volgorde van toestanden
3Een led schakelen met een knopread digital pin, if … elseInvoer en uitvoer, voorwaarden
4Automatisch nachtlampjeread analog pin, operator kleiner danAnaloge waarde, drempel
5Led-dimmer met een potmeterread analog pin, set pwm pin, delingSchalen, PWM
6Servo-slagboomset servo pin, vermenigvuldiging en delingVerhouding, hoek
7Deurbel en melodieplay pin with note, repeatFrequentie, noten, herhaling
8Parkeersensor (HC-SR04-extensie)Extensieblok, if … else, buzzerExtensies toevoegen, afstand meten
9Batspel op het podium met een potmeterLive-modus, variabele, beweging van spritesInteractie tussen hardware en software

De getalomzettingen zijn het leerzaamste deel van de lessen. De potmeter geeft een waarde van 0 tot 1023, terwijl PWM 0 tot 255 verwacht; in activiteit 5 deel je de meting dus door 4 (1023 ÷ 4 ≈ 255). Om dezelfde waarde om te zetten in een hoek voor de servo, bouw je met operatorblokken value × 180 ÷ 1023. In activiteit 9 geef je de Arduino in de Live-modus het script "when green flag clicked, forever, set [pot] to (read analog pin A1)"; op de sprite gebruik je dezelfde variabele in een blok set x to (pot × 480 ÷ 1023 − 240) om het bat over de breedte van het podium te verspreiden, van −240 tot 240. Als je bij het maken van de variabele de optie "for all sprites" niet aanvinkt, kunnen het apparaat en de sprite dezelfde variabele niet zien. Voor de parkeersensor open je het Extension Center met de knop + extension onderaan het blokkenpalet en voeg je een extensie voor een ultrasone sensor toe; de meeste van deze extensies zijn gemaakt door ontwikkelaars uit de community, dus blokkennamen en ondersteunde pins verschillen per extensie. Hoe de sensor werkt, lees je in het artikel HC-SR04-afstandssensor en de frequenties van noten in het artikel buzzer.

Kleine maar nuttige gewoonten voor in de klas: laat elke leerling het project met zijn naam opslaan als .mblock-bestand, klik met de rechtermuisknop op het scriptgebied om blokken als afbeelding te exporteren en deel ze op het whiteboard of een werkblad, en gebruik de functies voor blokken zoeken en blokken uitschakelen in nieuwere versies om een foutief deel tijdelijk uit te zetten zonder het te verwijderen. Als leerlingen in tweetallen werken (een ordent de blokken, de ander controleert de schakeling), gaat het debuggen sneller en is er minder kabelchaos.

Overstappen naar de Arduino IDE: van blokken naar echte code

Op een gegeven moment zijn blokken niet genoeg meer: naarmate programma's groeien wordt het scriptgebied rommelig, heb je een sensorbibliotheek nodig die niet in het Extension Center staat, of wil je meerdere taken tegelijk uitvoeren zonder delay. Dan is het tijd voor de installatie van de Arduino IDE en de overstap naar tekstcode; het toevoegen van bibliotheken voor nieuwe sensoren heb je dan zelf in de hand. De overgang verloopt het soepelst als je een project dat je in mBlock hebt gemaakt, opnieuw schrijft in de Arduino IDE, zodat je twee weergaven van dezelfde logica naast elkaar ziet.

  1. Selecteer en kopieer in mBlock de code in het paneel Arduino C; open in de Arduino IDE een nieuwe sketch en plak de code erin.
  2. Kies het board (Arduino Uno) en de poort in het menu Tools en klik eerst op Verify en daarna op Upload. De code moet werken zoals in mBlock.
  3. Vereenvoudig de code daarna: verzamel de pinMode-regels in setup(), verplaats de inhoud van de while(1)-lus naar loop() en gebruik delay() of millis() in plaats van _delay().
  4. Verander float-variabelen waar passend in int of bool en geef pinnummers met const int een betekenisvolle naam.
  5. Print variabelen naar de Serial Monitor om te volgen wat het programma doet; dat is het tekstcode-equivalent van live monitoren in mBlock.

Hieronder staat het programma dat activiteit 3 en 4 combineert, een automatisch nachtlampje dat je met een knop aan- en uitzet, geschreven in de Arduino IDE. De pinnummers komen overeen met de bedradingstabel hierboven.

C++ (Arduino IDE)
1// mBlock gece lambası etkinliğinin Arduino IDE ile yazılmış hali
2// The mBlock night-light activity rewritten for the Arduino IDE
3const int LED_PIN = 5;         // LED + 220 ohm direnç (PWM pini) / LED + 220 ohm resistor (PWM pin)
4const int BUTON_PIN = 2;       // buton 5V'a, 10k pull-down GND'ye / button to 5V, 10k pull-down to GND
5const int LDR_PIN = A0;        // LDR + 10k gerilim bölücü / LDR + 10k voltage divider
6const int ESIK = 400;          // bu değerin altı "karanlık" sayılır / below this value counts as "dark"
7
8bool sistemAcik = true;        // butonla açılıp kapanır / toggled with the button
9int oncekiButon = LOW;         // önceki buton durumu / previous button state
10unsigned long sonYazma = 0;    // son Seri Monitör yazma zamanı / last Serial Monitor print time
11
12void setup() {
13  pinMode(LED_PIN, OUTPUT);
14  pinMode(BUTON_PIN, INPUT);   // harici pull-down olduğu için INPUT / INPUT because of the external pull-down
15  Serial.begin(9600);          // Seri Monitör 9600 baud / Serial Monitor at 9600 baud
16}
17
18void loop() {
19  int buton = digitalRead(BUTON_PIN);
20  if (buton == HIGH && oncekiButon == LOW) {   // yalnız basıldığı an / only at the moment of the press
21    sistemAcik = !sistemAcik;
22    delay(30);                                 // basit debounce / simple debounce
23  }
24  oncekiButon = buton;
25
26  int isik = analogRead(LDR_PIN);              // 0 karanlık, 1023 aydınlık / 0 dark, 1023 bright
27  if (sistemAcik && isik < ESIK) {
28    int parlaklik = map(isik, 0, ESIK, 255, 40);   // karardıkça daha parlak / brighter as it gets darker
29    analogWrite(LED_PIN, parlaklik);
30  } else {
31    analogWrite(LED_PIN, 0);
32  }
33
34  if (millis() - sonYazma >= 500) {            // delay olmadan yarım saniyede bir yaz / print every half second without delay
35    sonYazma = millis();
36    Serial.print("Isik: ");
37    Serial.print(isik);
38    Serial.print("  Sistem: ");
39    Serial.println(sistemAcik ? "acik" : "kapali");
40  }
41}

Kijk hoe het verschilt van de mBlock-versie: setup() draait maar één keer en maakt de pins klaar, terwijl loop() zichzelf herhaalt, dus while(1) is niet nodig. De knop wordt vergeleken met zijn vorige toestand en alleen op het moment van indrukken geregistreerd; anders zou het systeem, zolang je vinger op de knop zit, honderden keren per seconde schakelen. De functie map() schaalt de LDR-waarde naar een waarde tussen 255 en 40, zodat de led feller brandt naarmate de kamer donkerder wordt. Het printen naar de Serial Monitor gebeurt elke halve seconde met millis() in plaats van delay(), zodat het programma tijdens het wachten geen druk op de knop mist. De details van deze techniek vind je in millis vs delay en meer over het printen van data in het artikel Arduino Serial Monitor.

Hetzelfde programma op de ESP32 en Raspberry Pi Pico

De apparaatbibliotheek van mBlock bevat eigen boards van Makeblock op basis van de ESP32, zoals CyberPi en HaloCode, maar er is geen officieel apparaat voor een gewoon ESP32-ontwikkelboard of de Raspberry Pi Pico; de community-extensies die je soms ziet, veranderen ook van versie tot versie. Het goede nieuws is dat de logica die je met blokken hebt geleerd, niet per board verandert. Als je de ESP32 met de Arduino IDE programmeert, gebruik je bijna dezelfde code; alleen de pinnummers, de werkspanning van 3,3 V en de 12-bits schaal van 0–4095 van de ADC veranderen. Daarom wordt de donkerdrempel ongeveer 1600 in plaats van 400.

C++ (Arduino IDE)
1// Aynı gece lambası ESP32'de (Arduino IDE) / The same night light on the ESP32 (Arduino IDE)
2const int LED_PIN = 18;        // LED + 220 ohm direnç / LED + 220 ohm resistor
3const int BUTON_PIN = 4;       // buton 3V3'e, 10k pull-down GND'ye / button to 3V3, 10k pull-down to GND
4const int LDR_PIN = 34;        // ADC1 girişi, LDR + 10k bölücü (3V3) / ADC1 input, LDR + 10k divider (3V3)
5const int ESIK = 1600;         // ESP32 ADC 12 bit: 0-4095 / ESP32 ADC is 12-bit: 0-4095
6
7bool sistemAcik = true;        // butonla açılıp kapanır / toggled with the button
8int oncekiButon = LOW;         // önceki buton durumu / previous button state
9unsigned long sonYazma = 0;    // son yazma zamanı / last print time
10
11void setup() {
12  pinMode(LED_PIN, OUTPUT);
13  pinMode(BUTON_PIN, INPUT);   // harici pull-down / external pull-down
14  Serial.begin(115200);        // ESP32 için yaygın hız / common speed for the ESP32
15}
16
17void loop() {
18  int buton = digitalRead(BUTON_PIN);
19  if (buton == HIGH && oncekiButon == LOW) {   // yalnız basıldığı an / only at the moment of the press
20    sistemAcik = !sistemAcik;
21    delay(30);                                 // basit debounce / simple debounce
22  }
23  oncekiButon = buton;
24
25  int isik = analogRead(LDR_PIN);              // 0 karanlık, 4095 aydınlık / 0 dark, 4095 bright
26  if (sistemAcik && isik < ESIK) {
27    analogWrite(LED_PIN, map(isik, 0, ESIK, 255, 40));   // karardıkça daha parlak / brighter as it gets darker
28  } else {
29    analogWrite(LED_PIN, 0);
30  }
31
32  if (millis() - sonYazma >= 500) {            // yarım saniyede bir yaz / print every half second
33    sonYazma = millis();
34    Serial.printf("Isik: %d  Sistem: %s\n", isik, sistemAcik ? "acik" : "kapali");
35  }
36}

Op de Raspberry Pi Pico is MicroPython de gebruikelijkste route. Het onderstaande programma, dat je in de Thonny-editor uitvoert, doet hetzelfde werk: read_u16() geeft de ADC-waarde van 0 tot 65535 terug en duty_u16() verwacht de PWM-duty cycle op dezelfde schaal. Waarom Python een goede tweede stap na programmeren met blokken is, leggen we uit in het artikel Basis van MicroPython.

MicroPython
1# Aynı gece lambası Raspberry Pi Pico'da (MicroPython) / The same night light on Raspberry Pi Pico (MicroPython)
2from machine import Pin, ADC, PWM
3import time
4
5led = PWM(Pin(14))                     # LED + 220 ohm direnç / LED + 220 ohm resistor
6led.freq(1000)                         # PWM frekansı 1 kHz / PWM frequency 1 kHz
7buton = Pin(2, Pin.IN, Pin.PULL_DOWN)  # buton 3V3'e, pull-down / button to 3V3, pull-down
8ldr = ADC(26)                          # GP26 = ADC0, LDR + 10k bölücü / GP26 = ADC0, LDR + 10k divider
9ESIK = 25000                           # 0-65535 arası karanlık eşiği / darkness threshold on 0-65535
10
11sistem_acik = True                     # butonla açılıp kapanır / toggled with the button
12onceki = 0                             # önceki buton durumu / previous button state
13son_yazma = time.ticks_ms()            # son yazma zamanı / last print time
14
15while True:
16    b = buton.value()
17    if b == 1 and onceki == 0:         # yalnız basıldığı an / only at the moment of the press
18        sistem_acik = not sistem_acik
19        time.sleep_ms(30)              # basit debounce / simple debounce
20    onceki = b
21
22    isik = ldr.read_u16()              # 0 karanlık, 65535 aydınlık / 0 dark, 65535 bright
23    if sistem_acik and isik < ESIK:
24        # karardıkça daha parlak / brighter as it gets darker
25        led.duty_u16(65535 - isik * 55000 // ESIK)
26    else:
27        led.duty_u16(0)
28
29    if time.ticks_diff(time.ticks_ms(), son_yazma) >= 500:   # yarım saniyede bir / every half second
30        son_yazma = time.ticks_ms()
31        print("Isik:", isik, " Sistem:", "acik" if sistem_acik else "kapali")

Dezelfde projecten als blokken op je telefoon openen

Als je op afstand van de computer verder wilt werken met de blokkenlogica die je in mBlock hebt gebouwd, bekijk dan de BlueGrays-app. De code van meer dan 100 Arduino-, ESP32- en Raspberry Pi Pico-projecten in de app is ook beschikbaar in onze eigen blokken op basis van Blockly. Zet in een project Toon als blokken aan en de code wordt vervangen door hetzelfde programma in blokken; het tabblad Blokken uitgelegd legt dan stap voor stap uit wat elk blok doet. De activiteiten met led, stoplicht, knop-led, LDR-nachtlampje, buzzer, parkeersensor en potmeterservo uit deze gids staan er allemaal, zowel als blokken als als Arduino C-code, en je schakelt met één tik tussen de twee. Als je de volgorde die je in mBlock hebt gebouwd vergelijkt met de blokken in de app, zie je gemakkelijk hoe dezelfde logica in twee verschillende tools in elkaar zit.

Voor de ESP32 en de Pico, die zoals hierboven genoemd geen officieel mBlock-apparaat hebben, heeft de app ook projecten met blokken: bekijk eerst de blokversie en ga dan verder met de Arduino C- of MicroPython-code van hetzelfde project. In de Codegids van de app worden de voorbeelden voor basiscommando's zoals digitalWrite, if/else en lussen ook als blokken getoond. Wil je het geleerde versterken, dan geven de Vragen van de dag je elke dag 5 vragen, verdeeld over niveaus van A1 tot C2, plus een wekelijkse ranglijst en badges.

Veelvoorkomende verbindingsproblemen en oplossingen

SymptoomWaarschijnlijke oorzaakOplossing
De poortlijst is leegKabel die alleen laadt of geen CH340-stuurprogrammaGebruik een datakabel en installeer het CH340-stuurprogramma; Apparaatbeheer moet een regel tonen zoals "USB-SERIAL CH340 (COM3)"
De poort verschijnt maar verbindt nietEen ander programma gebruikt de poortSluit de Serial Monitor van de Arduino IDE, een tweede mBlock-venster of de webtab
Verbonden, maar het uploaden misluktVerkeerd board gekozen in de Device LibraryKies het exacte boardmodel; probeer bij een Nano-kloon Arduino Nano (old)
De poortlijst opent niet in de webversieDe browser ondersteunt geen seriële poortenGebruik een actuele versie van Chrome of Edge
De Leonardo verbindt niet in de webversieDirecte verbinding ondersteunt de Leonardo, Micro en Yun nietInstalleer mLink of gebruik de desktopversie
Blokken reageren niet in de Live-modusGeen firmware, of die is gewist door een geüpload programmaUpload de firmware opnieuw via Setting > Update Firmware
Het uploaden is klaar maar het programma draait nietDe blokken staan niet onder when Arduino Uno starts upKoppel het programma aan het hat-blok; losse blokken worden niet omgezet in code
Het programma loopt vast of het board blijft resettenEen servo of motor trekt te veel stroom van USBVoed servo's en motoren met een externe voeding van 5 V en verbind de GND's met elkaar
mLink installeert of opent nietAntivirussoftware of een firewall blokkeert hetSta de installatie toe en zet mLink op de lijst met vertrouwde programma's

Een snelle manier om te zien of het probleem bij mBlock of bij het board ligt, is het voorbeeld Blink met de Arduino IDE naar hetzelfde board te uploaden. Als de Arduino IDE ook een fout toont zoals avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x00, kunnen het board en de computer niet communiceren: dan zit het probleem in de poort, de kabel, het boardtype of de bootloader. Alle oorzaken van deze fout behandelen we in de gids Arduino-code wordt niet geüpload; meer over de CH340-chip en zijn stuurprogramma's lees je in het artikel USB-TTL-converter. Als het board zichzelf reset terwijl er een servo is aangesloten, helpen de voedingstips in Arduino blijft resetten.

In de Live-modus voert een klik op een blok of een stapel blokken het één keer uit. Als je een probleem zoekt, draai dan niet het hele programma; test de blokken één voor één: als het ledblok werkt maar het knopblok steeds dezelfde waarde teruggeeft, zit het probleem in de schakeling en niet in de blokken. Sommige leesblokken hebben een selectievakje ernaast; vink het aan en de waarde wordt live op het podium getoond.

Projectideeën die je met mBlock kunt bouwen

  • Stoplicht met een voetgangersknop: druk op de knop en het autolicht springt op rood terwijl het groen voor voetgangers aangaat; voor de schakeling en de code zie het artikel Arduino-stoplicht.
  • Parkeersensor: een piep die sneller wordt en steeds meer leds die gaan branden naarmate de HC-SR04 een kortere afstand meet.
  • Robot die obstakels ontwijkt: een wagentje met twee motoren en een afstandssensor dat het obstakel voor zich ziet en van richting verandert; details in de gids robot die obstakels ontwijkt.
  • Lijnvolgende robot: een wedstrijdrobot die met infraroodsensoren zwarte tape volgt (lijnvolgende robot).
  • Podiumbesturing: een spel in de Live-modus waarin een potmeter of joystick een ruimteschip op het podium bestuurt.
  • Automatische planten water geven: een systeem dat een kleine pomp aanzet wanneer een bodemvochtsensor droge grond detecteert.
  • Servoradar: een project dat de omgeving scant met een afstandssensor op een servo en een radarscherm op het podium tekent (Arduino-radar).
  • Robotwagen: neem de motor- en sensorlogica die je in mBlock hebt geleerd mee naar het project Arduino-robotwagen.

mBlock is de vriendelijkste manier om een echte Arduino te programmeren met het gemak van programmeren met blokken en om door te stappen naar tekstcode wanneer je er klaar voor bent. Heb je nog geen board, dan kun je dezelfde activiteiten in de browser uitproberen met de Tinkercad Arduino-simulatie. In de BlueGrays-app vind je stap-voor-stap schakelschema's en code voor de projecten met led, stoplicht, knop-led, LDR-nachtlampje, buzzer, HC-SR04-parkeersensor en potmeterservo, en je kunt dezelfde projecten ook als blokken openen, zodat je van elke activiteit die je in mBlock hebt gebouwd met één tik de blokversie en de tekstcodeversie kunt vergelijken.

Veelgestelde vragen

Is mBlock gratis?

Ja. De desktop-, web- en mobiele versies van mBlock 5 zijn gratis en je hebt zelfs geen account nodig om een Arduino te programmeren. Alleen sommige extensies die AI en clouddiensten gebruiken, hebben een dagelijkse gebruikslimiet en vragen je om in te loggen.

Waarom herkent mBlock mijn Arduino niet?

De meest voorkomende oorzaken zijn een USB-kabel die alleen laadt of een ontbrekend CH340-stuurprogramma; de meeste kloonboards gebruiken deze chip. Steek het board met een datakabel rechtstreeks in de computer, installeer het CH340-stuurprogramma en sluit programma's die de poort gebruiken, zoals de Serial Monitor van de Arduino IDE. Verschijnt de poort niet, vink dan in het verbindingsvenster Show all connectable devices aan en kies de juiste poort handmatig.

Wat is het verschil tussen de Live-modus en de Upload-modus in mBlock?

In de Live-modus draait het programma op de computer en stuurt het commando's via USB naar de Arduino; je ziet het resultaat direct, maar het programma stopt als de kabel wordt losgekoppeld en het board heeft de mBlock-firmware nodig. In de Upload-modus worden de blokken vertaald naar Arduino C en permanent naar het board geschreven; het programma draait zonder de kabel en moet beginnen met het blok when Arduino Uno starts up.

Kan ik mBlock-code in de Arduino IDE gebruiken?

Ja. Open in de Upload-modus het paneel Arduino C rechts, kopieer de code en plak en compileer hem in de Arduino IDE. mBlock maakt van het blok forever een while(1)-lus binnen setup() en declareert variabelen als float; de code werkt zoals hij is, maar het is verstandig hem voor de leesbaarheid te vereenvoudigen tot de gebruikelijke loop()-structuur.

Ondersteunt mBlock de ESP32 of Raspberry Pi Pico?

mBlock kan de ESP32-boards van Makeblock zoals CyberPi en HaloCode programmeren, maar er is geen officiële apparaatondersteuning voor gewone ESP32-ontwikkelboards of de Raspberry Pi Pico. Voor die boards gebruik je beter de Arduino IDE voor de ESP32 en MicroPython in Thonny voor de Pico; de logica die je met blokken hebt geleerd, blijft gelden.

Moet ik mBlock 3 of mBlock 5 gebruiken?

Als je net begint, gebruik dan mBlock 5. De op Flash gebaseerde webeditor van mBlock 3 werkt niet meer in actuele browsers en de 32-bits Mac-versie opent niet op macOS 10.15 en nieuwer. mBlock 5 is gebaseerd op Scratch 3.0, kan mBlock 3- en Scratch-projecten openen en er worden nieuwe boards en extensies aan toegevoegd.

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
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 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
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
Een buzzer gebruiken
AR-13Beginner

Een buzzer gebruiken

Heb je je ooit afgevraagd hoe een deurbel of alarm geluid maakt? De Arduino laat een kleine buzzer met korte tussenpozen piepen: piep, pauze, piep, pauze.

4.7(92)
170
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
Servomotor aansturen met een potentiometer
AR-36Beginner
Premium

Servomotor aansturen met een potentiometer

Als je aan de knop van de potentiometer draait, draait de arm van de servomotor mee: het ene uiteinde van de knop staat voor nul graden, het andere voor een halve slag.

4.6(37)
53
Parkeersensor met HC-SR04
AR-28Gemiddeld
Premium

Parkeersensor met HC-SR04

Een minversie van de parkeersensor van een auto: hoe dichterbij iets komt, hoe sneller de pieptonen.

4.8(64)
86