mBlock Arduino Anleitung: Installation, Live- und Upload-Modus

Einen Arduino mit mBlock zu programmieren ist einer der einfachsten Wege, einen Arduino Uno eine LED blinken zu lassen oder einen Taster und Sensoren auszulesen, ohne eine einzige Zeile Code zu schreiben. mBlock 5, das Makeblock kostenlos entwickelt, ist eine blockbasierte Programmierumgebung auf Basis von Scratch 3.0: Du steckst bunte Blöcke wie ein Puzzle zusammen, und mBlock übersetzt sie im Hintergrund in Arduino-C-Code, kompiliert ihn und lädt ihn auf dein Board. Du kannst die Blöcke aber auch sofort auf dem Board ausführen und mit Figuren auf der Bühne zusammenspielen lassen. Deshalb gehört mBlock zu den beliebtesten Werkzeugen im Robotik- und Informatikunterricht, bei Schülerprojekten für Wettbewerbe und für den ersten Schritt mit Arduino.

In dieser Anleitung erfährst du Schritt für Schritt, wie du mBlock auf deinem Computer installierst oder im Browser nutzt, einen Arduino Uno als Gerät hinzufügst und verbindest, die Firmware für den Live-Modus aufspielst, worin sich Live-Modus und Upload-Modus unterscheiden, welche Blöcke es für LED, Taster und Sensoren gibt, in welche Arduino-C-Zeilen die Blöcke übersetzt werden, welche neun Übungen sich für den Unterricht eignen, wie der Umstieg auf die Arduino IDE gelingt und wie du die häufigsten Verbindungsprobleme löst.

Was ist mBlock und wie funktioniert es mit Arduino?

mBlock ist eine Programmierumgebung, die auf dem am MIT entwickelten Scratch 3.0 aufbaut. Der größte Unterschied zu Scratch: Neben den Figuren auf dem Bildschirm kann mBlock auch echte Hardware programmieren. Die Oberfläche hat dafür zwei getrennte Tabs: Im Tab Sprites (Figuren) programmierst du die Figuren auf der Bühne, im Tab Devices (Geräte) Boards wie Arduino, micro:bit oder Makeblock-Roboter. Sobald du ein Gerät auswählst, kommen boardspezifische Kategorien zur Blockpalette hinzu; beim Arduino Uno sind das die Pin- und Seriell-Blöcke. Im Upload-Modus wird dein Blockskript in Arduino C übersetzt, in Maschinencode kompiliert und über USB in den Flash-Speicher des Boards geschrieben. mBlock erledigt also dieselbe Arbeit wie die Arduino IDE, nur mit einer Blockoberfläche, und weil es dir den erzeugten Code zeigt, erleichtert es auch den Umstieg auf Textcode.

mBlock installieren: Desktop- und Web-Version

1. Öffne im Browser mblock.cc und lade auf der Download-Seite die mBlock 5 Desktop-Version für dein Betriebssystem herunter. Aktuell ist zum Zeitpunkt dieses Artikels V5.6; unterstützt werden 64-Bit-Windows ab Version 7 und macOS ab 10.12, für Macs mit Apple-M-Chip gibt es ein eigenes Installationspaket.
2. Starte unter Windows das Installationsprogramm und folge dem Assistenten. Wenn es anbietet, den CH340-Treiber zu installieren, nimm an: Die meisten Arduino-Klone nutzen diesen USB-Seriell-Chip, und ohne Treiber taucht der Port nicht auf.
3. Lässt sich die Installationsdatei unter macOS nicht öffnen, klicke sie mit der rechten Maustaste an und wähle Öffnen, oder nutze in den Systemeinstellungen unter Datenschutz & Sicherheit die Schaltfläche Dennoch öffnen.
4. Öffne mBlock und stelle über das Globus-Symbol im oberen Menü die Sprache auf Deutsch. Danach erscheinen Menüs und Blocknamen auf Deutsch.
5. Auf Schulrechnern, auf denen du nichts installieren darfst, öffnest du ide.mblock.cc im Browser; für die Arduino-Verbindung brauchst du eine aktuelle Version von Chrome oder Edge.

Lange Zeit verband sich die Web-Version über ein kleines Hilfsprogramm namens mLink mit dem Board. In neueren Versionen ist die Standardmethode eine direkte Verbindung über die serielle Schnittstelle des Browsers: Wenn du auf Verbinden klickst, öffnet der Browser ein Fenster, du wählst den Port des Arduino aus und bist ohne zusätzliche Software verbunden. Das funktioniert mit Uno, Nano, Nano (old) und Mega 2560; Boards, die USB anders nutzen, etwa Leonardo, Micro und Yun, brauchen weiterhin mLink. Solange mLink läuft, siehst du in der Taskleiste ein kleines Panda-Symbol. Lass Desktop- und Web-Version oder zwei mBlock-Tabs nicht gleichzeitig offen; beide versuchen denselben Port zu belegen, und die Verbindung schlägt fehl.

Gerät hinzufügen: Arduino Uno mit mBlock verbinden

1. Schließe den Arduino per USB-Kabel an den Computer an; die ON-LED (Betrieb) auf dem Board sollte leuchten.
2. Wechsle in mBlock unter der Bühne zum Tab Devices (Geräte). Entferne das standardmäßig vorhandene Makeblock-Gerät (je nach Version Codey Rocky oder CyberPi) über das Kreuz in seiner Ecke.
3. Klicke auf + Add (hinzufügen), tippe in der Gerätebibliothek "Arduino" ins Suchfeld, wähle Arduino Uno und klicke auf OK. Klickst du auf den Stern oben links auf der Kachel, hat mBlock das Board beim nächsten Start gleich parat.
4. Klicke auf Connect (verbinden). Wähle im Tab USB des Fensters den Port, den mBlock gefunden hat: Unter Windows heißt er zum Beispiel COM3 oder COM4, unter macOS /dev/cu.usbmodem… oder bei Boards mit CH340 /dev/cu.wchusbserial…. Fehlt der Port in der Liste, setze das Häkchen bei Show all connectable devices (alle verbindbaren Geräte anzeigen).
5. Klicke erneut auf Connect. Erscheint die Meldung "Device connected" (Gerät verbunden), bist du startklar; in der Blockpalette tauchen die Arduino-spezifischen Pin- und Seriell-Blöcke auf.

Das richtige Gerät auszuwählen ist schon die halbe Miete. Egal ob Original oder Klon: Wähle für einen Uno Arduino Uno und für einen Mega Arduino Mega2560. Die meisten günstigen Arduino-Nano-Klone haben den alten Bootloader; bei diesen Boards scheitert das Hochladen mit Arduino Nano, mit der Option Arduino Nano (old) klappt es. Neuere Boards mit anderem Prozessor wie der Arduino Uno R4 lassen sich mit dem Uno-Gerät von mBlock nicht programmieren; nutze dafür direkt die Arduino IDE. Wenn du noch nicht weißt, welches Board du kaufen sollst, lies Welchen Arduino soll ich kaufen?, und die Pinbelegung des Nano findest du in der Anleitung Arduino Nano Pinout.

Live-Modus und Upload-Modus: der Unterschied

mBlock bietet beim Programmieren von Geräten zwei Modi, zwischen denen du mit dem Schalter im Tab Devices wechselst. Im Live-Modus läuft das Programm eigentlich auf dem Computer: mBlock liest Block für Block und schickt dem Arduino über USB Befehle wie "schalte Pin 13 ein" oder "lies A0 und sende mir den Wert". Dafür braucht der Arduino eine spezielle Firmware, die diese Befehle versteht. Du siehst das Ergebnis sofort, kannst Sensorwerte auf der Bühne beobachten und den Arduino mit den Figuren reden lassen, doch sobald du das USB-Kabel ziehst oder mBlock schließt, stoppt das Programm. Im Upload-Modus werden die Blöcke in Arduino C übersetzt, kompiliert und dauerhaft auf das Board geschrieben; auch ohne Kabel läuft das Programm mit Batterie oder Netzteil weiter. In diesem Modus muss dein Programm unter dem Hutblock when Arduino Uno starts up (wenn Arduino Uno startet) stehen; Bühnenereignisse wie die grüne Flagge werden nicht auf das Board übertragen.

Firmware aufspielen: den Arduino für den Live-Modus vorbereiten

1. Verbinde den Arduino (Connect) und stelle den Modusschalter auf Live.
2. Hat das Board noch keine mBlock-Firmware, bietet mBlock meist ein Update an. Falls nicht, wähle im Menü Setting (Einstellungen) neben den Verbindungsknöpfen Update Firmware und starte die Aktualisierung im folgenden Fenster.
3. Während des Aufspielens flackern die TX- und RX-LEDs des Boards schnell; ziehe das Kabel nicht ab und schließe mBlock nicht, bis der Fortschrittsbalken fertig ist.
4. Zum Testen ziehst du aus den Pin-Blöcken set digital pin (13) output as (high) in den Skriptbereich und klickst ihn einmal an. Leuchtet die L-LED auf dem Board sofort, funktioniert der Live-Modus; klickst du denselben Block mit der Option (low) an, geht die LED aus.

Wichtige Arduino-Blöcke: LED, Taster und Sensoren

Sobald der Arduino Uno hinzugefügt ist, erscheinen in der Blockpalette neben den aus Scratch bekannten Kategorien Events (Ereignisse), Control (Steuerung), Operators (Operatoren), Variables (Variablen) und My Blocks (Meine Blöcke) boardspezifische Kategorien für Pins und die serielle Schnittstelle. In der deutschen Oberfläche erscheinen die Blöcke mit deutschen Namen; damit du sie sicher wiederfindest, stehen in der Tabelle unten die englischen Namen und ihre Funktion. Die Namen können sich je nach Version leicht unterscheiden; klickst du einen Block mit der rechten Maustaste an und wählst Help (Hilfe), zeigt mBlock eine Beschreibung. Beim Uno funktioniert PWM nur an den Pins 3, 5, 6, 9, 10 und 11; die komplette Pinbelegung siehst du im Werkzeug Pinout.

Schaltplan-Tabelle: ein Unterrichtsaufbau für alle Übungen

Die Schaltung jede Woche neu aufzubauen kostet Unterrichtszeit. Baust du die folgende Verdrahtung einmal auf dem Steckbrett auf, kannst du alle neun Übungen machen, ohne ein Kabel anzufassen. Den Vorwiderstand der LED prüfst du mit dem LED-Vorwiderstandsrechner, die Spannung des LDR-Spannungsteilers mit dem Werkzeug Spannungsteiler. Wenn du die Bauteile zum ersten Mal verwendest, findest du in den Artikeln zu LED, Taster, LDR und Servomotor jeweils den genauen Anschluss.

Erstes Programm: LED blinken lassen im Upload-Modus

1. Stelle den Modusschalter auf Upload.
2. Ziehe aus der Kategorie Events den Block when Arduino Uno starts up in den Skriptbereich.
3. Hänge darunter aus der Kategorie Control einen forever-Block (wiederhole fortlaufend) an.
4. Setze in den forever-Block nacheinander set digital pin (13) output as (high), wait (1) seconds, set digital pin (13) output as (low) und noch einmal wait (1) seconds.
5. Klicke auf Upload (hochladen). mBlock kompiliert den Code und schickt ihn ans Board; nach ein paar Sekunden meldet eine Nachricht, dass das Hochladen fertig ist.
6. Die L-LED auf dem Board blinkt jetzt im Sekundentakt. Ziehst du das USB-Kabel ab und versorgst das Board mit einer Powerbank oder einem 7–12-V-Netzteil, läuft das Programm weiter; die Möglichkeiten der Stromversorgung erklären wir in Arduino mit Batterie betreiben.

Wie werden Blöcke zu Arduino-C-Code?

Im Upload-Modus klickst du am rechten Rand auf die Arduino C Code-Schaltfläche (das Symbol mit spitzen Klammern), und mBlock zeigt in einem Feld den Code, der deinen Blöcken entspricht. Jede Änderung an den Blöcken aktualisiert den Code sofort; so lernst du am einfachsten, welcher Block welche Zeile erzeugt. Fügst du dem Blink-Programm oben eine Variable namens sayac (Zähler) hinzu und erhöhst sie bei jedem Durchlauf um 1, sieht der erzeugte Code ungefähr so aus. Die Kommentarzeilen haben wir ergänzt; Leerzeichen und die Position einiger Zeilen wie pinMode können je nach Version leicht abweichen.

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 diesem Code fallen vier Dinge auf. Erstens wird der Block forever nicht zur loop()-Funktion des Arduino, sondern zu einer endlosen while(1)-Schleife in setup(); loop() ruft nur die Funktion _loop() auf. Zweitens nutzt der Block wait statt delay() eine Funktion _delay(), die während des Wartens weiter _loop() aufruft, damit Erweiterungen ihre Hintergrundaufgaben erledigen können. Drittens wird jede in mBlock angelegte Variable als float (Kommazahl) deklariert; auf dem Uno belegt jede 4 Byte RAM und kann bei Gleichheitsvergleichen kleine Rundungsfehler verursachen. Eine Variable, die du in 0,1er-Schritten erhöhst, ist nach zehn Schritten zum Beispiel nicht unbedingt genau 1, deshalb ist ein Vergleich mit "größer als" oder "kleiner als" sicherer als "gleich". Viertens werden die Bibliotheken Wire und SoftwareSerial oben meist eingebunden, auch wenn du sie nicht nutzt; das Programm läuft trotzdem, belegt aber etwas mehr Speicher als eine handgeschriebene Version.

Übungen für den Robotik- und Programmierunterricht

Die neun Übungen unten sind für 40-minütige Unterrichtsstunden vom Einfachen zum Schweren geordnet und funktionieren alle mit dem einen Aufbau von oben. Es lohnt sich, jede Übung im Live-Modus zu beginnen: Die Schülerinnen und Schüler klicken einen Block an, sehen sofort das Ergebnis, beobachten Sensorwerte auf der Bühne und finden ihre Fehler selbst. Läuft das Programm wie gewünscht, vermittelt der Wechsel derselben Blöcke in den Upload-Modus und das dauerhafte Speichern auf dem Board die Idee eines "Geräts, das ohne Computer funktioniert". Die Programmierkonzepte hinter den Übungen findest du in Textcode im Artikel Arduino-Programmierung Grundlagen.

Die Zahlenumrechnungen sind der lehrreichste Teil der Stunden. Das Potentiometer liefert Werte von 0 bis 1023, PWM erwartet aber 0 bis 255; deshalb teilst du in Übung 5 den Messwert durch 4 (1023 ÷ 4 ≈ 255). Um denselben Wert beim Servo in einen Winkel umzurechnen, baust du mit Operator-Blöcken Wert × 180 ÷ 1023. In Übung 9 gibst du dem Arduino im Live-Modus das Skript "when green flag clicked, forever, set [pot] to (read analog pin A1)"; die Figur nutzt dieselbe Variable in einem Block set x to (pot × 480 ÷ 1023 − 240) und verteilt den Schläger so über die Bühnenbreite von −240 bis 240. Setzt du beim Anlegen der Variablen kein Häkchen bei "für alle Figuren", sehen Gerät und Figur nicht dieselbe Variable. Für die Einparkhilfe öffnest du mit der Schaltfläche + extension (Erweiterung) unten in der Blockpalette das Extension Center und fügst eine Ultraschallsensor-Erweiterung hinzu; die meisten dieser Erweiterungen stammen von Community-Entwicklern, daher unterscheiden sich Blocknamen und unterstützte Pins von Erweiterung zu Erweiterung. Wie der Sensor funktioniert, steht im Artikel HC-SR04 Ultraschallsensor, die Notenfrequenzen findest du im Artikel Buzzer.

Umstieg auf die Arduino IDE: von Blöcken zu echtem Code

Irgendwann reichen Blöcke nicht mehr: Längere Programme machen den Skriptbereich unübersichtlich, du brauchst eine Sensor-Bibliothek, die es im Extension Center nicht gibt, oder willst mehrere Aufgaben gleichzeitig ohne delay erledigen. Dann ist es Zeit für die Arduino IDE Installation und den Umstieg auf Textcode; das Hinzufügen von Bibliotheken für neue Sensoren liegt dann in deiner Hand. Am sanftesten gelingt der Umstieg, wenn du ein mBlock-Projekt in der Arduino IDE neu schreibst; so siehst du zwei Ansichten derselben Logik nebeneinander.

1. Markiere und kopiere in mBlock den Code im Arduino-C-Feld; öffne in der Arduino IDE einen neuen Sketch und füge ihn ein.
2. Wähle im Menü Werkzeuge das Board (Arduino Uno) und den Port, klicke zuerst auf Überprüfen und dann auf Hochladen. Der Code sollte genauso laufen wie in mBlock.
3. Vereinfache den Code anschließend: Sammle die pinMode-Zeilen in setup(), verschiebe den Inhalt der while(1)-Schleife nach loop() und nutze statt _delay() lieber delay() oder millis().
4. Mach aus float-Variablen je nach Bedarf int oder bool und gib den Pinnummern mit const int sprechende Namen.
5. Gib Variablen im Seriellen Monitor aus, um zu verfolgen, was das Programm tut; das ist im Textcode das Gegenstück zur Live-Anzeige in mBlock.

Unten steht das Programm, das die Übungen 3 und 4 kombiniert, also ein automatisches Nachtlicht, das du per Taster ein- und ausschaltest, geschrieben für die Arduino IDE. Die Pinnummern entsprechen der Schaltplan-Tabelle oben.

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}

Achte auf die Unterschiede zur mBlock-Version: setup() läuft nur einmal und bereitet die Pins vor, loop() wiederholt sich von selbst, deshalb braucht es kein while(1). Der Taster wird mit seinem vorherigen Zustand verglichen und nur im Moment des Drückens gezählt; sonst würde das System umschalten, solange dein Finger auf dem Taster liegt, und zwar hunderte Male pro Sekunde. Die Funktion map() skaliert den LDR-Wert auf 255 bis 40, sodass die LED heller leuchtet, je dunkler es wird. Die Ausgabe im Seriellen Monitor erfolgt alle halbe Sekunde mit millis() statt delay(), damit das Programm beim Warten keinen Tastendruck verpasst. Mehr zu dieser Technik findest du in millis statt delay, zur Datenausgabe im Artikel Arduino Serial Monitor.

Dasselbe Programm auf ESP32 und Raspberry Pi Pico

In der Gerätebibliothek von mBlock findest du Makeblocks eigene ESP32-basierte Boards wie CyberPi und HaloCode, aber kein offizielles Gerät für ein normales ESP32-Entwicklungsboard oder den Raspberry Pi Pico; die gelegentlich auftauchenden Community-Erweiterungen ändern sich zudem von Version zu Version. Die gute Nachricht: Die Logik, die du mit Blöcken gelernt hast, ändert sich von Board zu Board nicht. Programmierst du den ESP32 mit der Arduino IDE, nutzt du fast denselben Code; anders sind nur die Pinnummern, die Betriebsspannung von 3,3 V und die 12-Bit-Skala des ADC von 0 bis 4095. Deshalb liegt die Dunkelschwelle bei etwa 1600 statt 400.

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}

Beim Raspberry Pi Pico ist MicroPython der übliche Weg. Das folgende Programm, das du im Editor Thonny ausführst, erledigt dieselbe Aufgabe: read_u16() liefert den ADC-Wert von 0 bis 65535, und duty_u16() erwartet das PWM-Tastverhältnis auf derselben Skala. Warum Python nach der Blockprogrammierung ein guter zweiter Schritt ist, erklären wir im Artikel MicroPython Grundlagen.

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")

Dieselben Projekte als Blöcke auf dem Handy öffnen

Wenn du die Blocklogik aus mBlock auch abseits des Computers weiterverfolgen willst, schau dir die BlueGrays App an. Der Code von mehr als 100 Arduino-, ESP32- und Raspberry-Pi-Pico-Projekten in der App liegt auch in unseren eigenen, auf Blockly basierenden Blöcken vor. Schaltest du bei einem Projekt Als Blöcke zeigen ein, erscheint statt des Codes dasselbe Programm als Blöcke; der Tab Blöcke verstehen erklärt dann Schritt für Schritt, was jeder Block macht. Die Übungen LED, Ampel, LED mit Taster, LDR-Nachtlicht, Summer, Einparkhilfe und Servo mit Potentiometer aus dieser Anleitung findest du dort alle, als Blöcke und als Arduino-C-Code, und mit einem Tippen wechselst du zwischen beiden. Vergleichst du deine eigene Blockfolge aus mBlock mit den Blöcken in der App, siehst du leicht, wie dieselbe Logik in zwei verschiedenen Werkzeugen aufgebaut wird.

Auch für ESP32 und Pico, für die es wie oben beschrieben kein offizielles mBlock-Gerät gibt, hat die App Projekte mit Blöcken: Sieh dir zuerst die Blockversion an und wechsle dann zum Arduino-C- oder MicroPython-Code desselben Projekts. Im Code-Guide der App werden die Beispiele zu Grundbefehlen wie digitalWrite, if/else und Schleifen ebenfalls als Blöcke gezeigt. Wer das Gelernte festigen will, bekommt mit Fragen des Tages jeden Tag 5 Fragen in Stufen von A1 bis C2, dazu eine Wochenrangliste und Abzeichen.

Häufige Verbindungsprobleme und Lösungen

Ob das Problem an mBlock oder am Board liegt, findest du am schnellsten heraus, indem du mit der Arduino IDE das Blink-Beispiel auf dasselbe Board lädst. Zeigt auch die Arduino IDE einen Fehler wie avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x00, können Board und Computer nicht miteinander kommunizieren: Das Problem liegt beim Port, beim Kabel, beim Board-Typ oder beim Bootloader. Alle Ursachen dieses Fehlers gehen wir in der Anleitung Arduino Sketch lässt sich nicht hochladen durch; mehr über den CH340-Chip und seine Treiber steht im Artikel USB-TTL-Adapter. Startet das Board mit angeschlossenem Servo immer wieder neu, helfen die Tipps zur Stromversorgung in Arduino startet ständig neu.

Projektideen mit mBlock

• Ampel mit Fußgängertaster: Auf Knopfdruck schaltet die Autoampel auf Rot und die Fußgängerampel auf Grün; Schaltung und Code findest du im Artikel Arduino Ampel.
• Einparkhilfe: Ein Piepton, der schneller wird, und mehr leuchtende LEDs, je kürzer der vom HC-SR04 gemessene Abstand ist.
• Hindernis-Ausweich-Roboter: Ein Fahrzeug mit zwei Motoren und einem Abstandssensor, das Hindernisse erkennt und die Richtung ändert; Details in der Anleitung Hindernis-Ausweich-Roboter.
• Linienfolger-Roboter: Ein Wettbewerbsroboter, der mit Infrarotsensoren einer schwarzen Linie folgt (Linienfolger).
• Bühnen-Controller: Ein Live-Modus-Spiel, in dem ein Potentiometer oder Joystick ein Raumschiff auf der Bühne steuert.
• Automatische Pflanzenbewässerung: Ein System, das eine kleine Pumpe einschaltet, sobald ein Bodenfeuchtesensor trockene Erde meldet.
• Servo-Radar: Ein Projekt, das mit einem Abstandssensor auf einem Servo die Umgebung abtastet und auf der Bühne einen Radarschirm zeichnet (Arduino Radar).
• Roboterauto: Übertrage die Motor- und Sensorlogik aus mBlock auf das Projekt Arduino Roboterauto bauen.

mBlock ist der sanfteste Weg, einen echten Arduino mit dem Komfort der Blockprogrammierung zu steuern und, wenn du so weit bist, auf Textcode umzusteigen. Hast du noch kein Board, kannst du dieselben Übungen mit der Tinkercad Arduino Simulation im Browser ausprobieren. In der BlueGrays App findest du für die Projekte LED, Ampel, LED mit Taster, LDR-Nachtlicht, Summer, HC-SR04-Einparkhilfe und Servo mit Potentiometer Schritt-für-Schritt-Schaltpläne und Code und kannst dieselben Projekte auch als Blöcke öffnen, sodass du zu jeder Übung, die du in mBlock gebaut hast, die Block- und die Textcode-Version mit einem Tippen vergleichen kannst.