In diesem Beitrag zeige ich dir, wie du den Funduino Cube per MQTT mit Node-RED nutzt. Als Mikrocontroller kommt dabei ein Raspberry Pi Pico 2 W zum Einsatz, der die Kommunikation mit dem MQTT-Broker übernimmt.
Mein erster Versuch mit einem Arduino Nano ESP32 hat nicht wie geplant funktioniert. Der Grund: Der Cube ist auf 5V ausgelegt, viele moderne Boards arbeiten aber mit 3,3V Logik.
Die Lösung ist eine passende Adapterplatine. In diesem Beitrag verwende ich den Raspberry Pi Pico 2 W auf dem Funduino Cube und zeige dir Schritt für Schritt, wie daraus ein spannendes MQTT-Projekt mit Node-RED wird.
Transparenzhinweis: Den Funduino Cube habe ich kostenfrei für ein Review erhalten. Entstanden ist der Kontakt auf der Maker Faire 2025 in Hannover, wo ich den Maker hinter dem Board persönlich getroffen habe. Nach einem sehr interessanten Austausch durfte ich den Cube mitnehmen und ausprobieren.
Meine Einschätzung in diesem Beitrag bleibt davon unabhängig. Ich zeige dir offen, was funktioniert, wo es Probleme gab und warum ich in diesem Projekt nun den Weg über den Raspberry Pi Pico 2 W mit Adapterplatine gehe.
Ausgangslage: Der Funduino Cube und mein erster Versuch
Der Funduino Cube ist ab Werk für den klassischen Arduino Nano vorbereitet. Das macht den Einstieg einfach, weil der Nano direkt aufgesteckt werden kann und viele Sensoren sowie Aktoren des Cubes sofort erreichbar sind.
Da ich den Cube aber nicht nur als reines Lernboard verwenden wollte, kam schnell die Idee auf, ihn für kleine IoT-Projekte zu nutzen. Dafür wäre ein Mikrocontroller mit WLAN natürlich deutlich praktischer. Mein erster Gedanke war daher der Arduino Nano ESP32.
Auf dem Papier klang das erstmal passend:
Der Formfaktor erinnert an den klassischen Nano, WLAN und Bluetooth sind direkt integriert und für spätere Projekte mit MQTT, Node-RED oder Home Assistant wäre das Board eigentlich eine spannende Grundlage gewesen.
In der Praxis zeigte sich jedoch recht schnell: Nur weil ein Board mechanisch ähnlich aussieht, heißt das nicht automatisch, dass es elektrisch sauber zum Funduino Cube passt.
Der Knackpunkt ist die unterschiedliche Logikspannung. Der Funduino Cube ist auf den klassischen Arduino Nano und damit auf ein 5V-Umfeld ausgelegt. Viele moderne Mikrocontroller-Boards, darunter auch ESP32-basierte Boards, arbeiten jedoch mit 3,3V Logik.
Genau hier wurde mein erster Versuch problematisch. Das Board ließ sich zwar grundsätzlich einsetzen, aber für einen zuverlässigen und sauberen Betrieb ist das keine Lösung, auf die ich in einem Projekt dauerhaft setzen möchte.
Die Lösung: Adapterplatinen für den Funduino Cube
Für den Funduino Cube gibt es spezielle Adapterplatinen, mit denen sich andere Mikrocontroller sauber auf dem Board verwenden lassen. Damit ist man nicht mehr nur auf den klassischen Arduino Nano beschränkt, sondern kann den Cube auch mit moderneren Boards betreiben.
Besonders interessant sind dabei Adapter für: Raspberry Pi Pico / Pico W / Pico 2 W und ESP32-WROOM32
In diesem Beitrag verwende ich den Adapter für den Raspberry Pi Pico 2 W. Der Pico 2 W ist für dieses Projekt besonders spannend, weil er WLAN direkt mitbringt und sich sehr gut mit MicroPython programmieren lässt.
Damit eignet er sich ideal für den nächsten Schritt: Der Funduino Cube soll nicht nur lokal Sensoren auslesen oder LEDs schalten, sondern später Daten per MQTT an Node-RED senden.
Für diesen ersten Teil geht es aber zunächst um die Grundlage: Der Pico 2 W soll sauber auf dem Funduino Cube sitzen und als neue Steuerzentrale für das Board vorbereitet werden.
Adapter richtig herum aufstecken
Auf der Rückseite der Adapterplatine befindet sich ein Hinweis, wie der Adapter auf den Funduino Cube gesteckt werden muss. Diese Markierung sollte man unbedingt beachten, bevor der Cube mit Spannung versorgt wird.
Gerade bei solchen Adapterplatinen ist die richtige Ausrichtung wichtig. Wird der Adapter falsch herum eingesetzt, können Pins falsch verbunden werden. Im schlimmsten Fall funktioniert der Aufbau nicht nur nicht, sondern es können auch der Raspberry Pi Pico 2 W, der Adapter oder der Funduino Cube beschädigt werden.
Ich habe daher vor dem Einstecken noch einmal genau geprüft, wie der Adapter ausgerichtet werden muss, und ihn erst danach vorsichtig auf den Sockel des Funduino Cube gesetzt.
Kurz gesagt: Nicht einfach aufstecken, sondern vorher die Beschriftung auf der Rückseite prüfen.
Hinweis: Vorher ein leeres Programm aufspielen
Solltest du den Raspberry Pi Pico 2 W bereits für andere Projekte verwendet haben, empfiehlt es sich, vor dem Einsetzen in den Funduino Cube ein leeres Programm aufzuspielen.
Der Grund ist einfach: Wenn auf dem Mikrocontroller noch ein altes Programm läuft, könnten einzelne GPIOs bereits beim Start als Ausgang geschaltet sein oder Signale ausgeben. Je nachdem, wie diese Pins auf dem Funduino Cube verbunden sind, kann das zu unerwartetem Verhalten führen.
Mit einem leeren Programm stellst du sicher, dass der Pico zunächst in einem definierten und unkritischen Zustand startet. Erst danach solltest du Schritt für Schritt die benötigten Pins für Sensoren, LEDs oder andere Komponenten des Funduino Cube ansprechen.
Ein einfaches leeres MicroPython-Programm kann zum Beispiel so aussehen:
# main.py
# Leeres Startprogramm für den Raspberry Pi Pico 2 W
while True:
pass
Damit läuft zwar noch kein eigentliches Projekt, aber der Pico führt auch keine alten GPIO-Befehle mehr aus einem vorherigen Aufbau aus.
Kurz gesagt: Wenn der Mikrocontroller schon einmal im Einsatz war, vorher lieber bereinigen und mit einem leeren Programm starten.
Programmierung mit Thonny starten
Nachdem der Raspberry Pi Pico 2 W korrekt auf dem Adapter sitzt und der Adapter richtig herum auf dem Funduino Cube steckt, können wir mit der Programmierung beginnen.
Für die Programmierung verwende ich in diesem Beitrag Thonny. Diese kleine IDE ist übersichtlich, leicht zu bedienen und trotzdem leistungsstark genug für viele Mikrocontroller-Projekte. Gerade wenn es um MicroPython auf dem Raspberry Pi Pico geht, ist Thonny für mich die erste Wahl.
Wie du Thonny installierst, den Raspberry Pi Pico vorbereitest und MicroPython auf den Mikrocontroller flashst, habe ich bereits in einem separaten Beitrag ausführlich beschrieben: Thonny IDE auf Linux einrichten für den Raspberry Pi Pico W
In diesem Beitrag setze ich daher voraus, dass Thonny bereits installiert ist und dein Raspberry Pi Pico 2 W mit MicroPython geflasht wurde.
Bevor wir nun den Funduino Cube ansteuern, empfiehlt es sich noch einmal zu prüfen, ob der Pico korrekt erkannt wird und ob ein einfaches Testprogramm ausgeführt werden kann. Erst danach starten wir mit den ersten Pins auf dem Funduino Cube.
Erste LED direkt mit MicroPython steuern
Bevor wir die LED später per MQTT schalten, testen wir zunächst den normalen Weg über ein einfaches MicroPython-Programm. Damit prüfen wir, ob der Raspberry Pi Pico 2 W korrekt auf dem Adapter sitzt und ob die rote LED auf dem Funduino Cube über den passenden GPIO angesprochen werden kann.
Die rote LED des Funduino Cube ist in diesem Aufbau mit GPIO12 verbunden. Das folgende Programm schaltet die LED im Abstand von 0,5 Sekunden ein und wieder aus.
import time
from machine import Pin
led_pin = Pin(12, Pin.OUT) #rote LED am Funduino cube am GPIO12
led_pin.value(0) #initial auf AUS
def main():
#Endlosschleife
while True:
led_pin.value(1) #LED AN
time.sleep(0.5) #Pause von 0,5 Sekunden
led_pin.value(0) #LED AUS
time.sleep(0.5) #Pause von 0,5 Sekunden
if __name__ == "__main__":
main()
Wenn das Programm auf den Pico 2 W übertragen und gestartet wird, sollte die rote LED auf dem Funduino Cube regelmäßig blinken.
Damit haben wir bestätigt, dass der GPIO korrekt angesprochen wird und die grundlegende Verbindung zwischen Pico 2 W, Adapterplatine und Funduino Cube funktioniert.
Der Ablauf ist hier noch komplett lokal: Das Programm läuft direkt auf dem Pico 2 W und entscheidet selbst, wann die LED ein- und ausgeschaltet wird. Im nächsten Schritt ändern wir genau das. Dann soll nicht mehr das Programm allein den Takt vorgeben, sondern eine Nachricht von außen.
Dafür verwenden wir anschließend MQTT. Der Pico 2 W abonniert dann ein Topic und reagiert auf empfangene Nachrichten, zum Beispiel on und off. Genau damit schaffen wir die Grundlage, um den Funduino Cube später über Node-RED zu steuern.
LED per MQTT steuern
Im vorherigen Beispiel haben wir die rote LED direkt über ein MicroPython-Programm blinken lassen. Der Pico 2 W hat dabei selbst entschieden, wann die LED ein- und ausgeschaltet wird.
Jetzt gehen wir einen Schritt weiter: Die LED soll über eine MQTT-Nachricht gesteuert werden. Damit kann später nicht nur der MQTT Explorer, sondern auch Node-RED einen Befehl an den Funduino Cube senden.
Für diesen ersten MQTT-Test verwende ich das Topic:
board/output/led
Der Pico 2 W abonniert dieses Topic und reagiert auf den empfangenen Payload:
AN
schaltet die rote LED ein.
AUS
schaltet die rote LED wieder aus.
Benötigte MQTT-Bibliothek installieren
Damit der Raspberry Pi Pico 2 W mit einem MQTT-Broker kommunizieren kann, benötigen wir die MicroPython-Bibliothek umqtt.simple.
Diese Bibliothek ist nicht immer automatisch vorhanden und muss daher ggf. vorher installiert werden. Das geht direkt über ein kleines MicroPython-Skript in Thonny.
Wichtig ist dabei: Der Pico 2 W muss dafür bereits mit dem WLAN verbunden sein, da mip.install() die Bibliothek aus dem Internet nachlädt.
Für meine WLAN-Zugangsdaten verwende ich wieder die Datei wifi_config.py. Darin sind WIFI_SSID und WIFI_PASSWORD gespeichert.
import time
import network
import mip
from wifi_config import WIFI_SSID, WIFI_PASSWORD
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(WIFI_SSID, WIFI_PASSWORD)
print("Verbinde mit WLAN:", WIFI_SSID)
while not wlan.isconnected():
time.sleep(0.5)
print("WLAN verbunden, IP:", wlan.ifconfig()[0])
mip.install("umqtt.simple")
print("umqtt.simple installiert")
Wenn das Skript erfolgreich durchgelaufen ist, sollte in der Ausgabe von Thonny am Ende folgende Meldung erscheinen:
Damit ist die benötigte MQTT-Bibliothek installiert und wir können im nächsten Schritt das eigentliche Programm zur LED-Steuerung per MQTT auf den Pico 2 W übertragen.
MicroPython-Programm für MQTT
Im folgenden Programm verbindet sich der Raspberry Pi Pico 2 W zuerst mit dem WLAN. Danach wird eine Verbindung zum MQTT-Broker aufgebaut und das Topic board/output/led abonniert.
Der MQTT-Broker läuft in meinem Fall unter der IP-Adresse:
192.168.178.186
"""
MQTT LED-Steuerung fuer Raspberry Pi Pico 2 W.
Abonniert das Topic 'board/output/led' und schaltet GPIO12 (D12)
abhaengig vom Payload:
- "AN" -> Pin HIGH
- "AUS" -> Pin LOW
Benoetigte Bibliothek: umqtt.simple
Installation z.B. ueber Thonny-REPL:
import mip
mip.install("umqtt.simple")
"""
import time
import network
from machine import Pin
from umqtt.simple import MQTTClient
from wifi_config import WIFI_SSID, WIFI_PASSWORD
# --- Konfiguration ---------------------------------------------------------
MQTT_BROKER = "192.168.178.186" # IP/Hostname des MQTT-Brokers
MQTT_PORT = 1883
MQTT_CLIENT_ID = "pico2w-led"
MQTT_TOPIC = b"board/output/led"
LED_PIN = 12 # GPIO12, entspricht "D12"
# --- Setup -------------------------------------------------------------
led_pin = Pin(LED_PIN, Pin.OUT)
led_pin.value(0)
def connect_wifi():
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
if not wlan.isconnected():
print("Verbinde mit WLAN:", WIFI_SSID)
wlan.connect(WIFI_SSID, WIFI_PASSWORD)
while not wlan.isconnected():
time.sleep(0.5)
print("WLAN verbunden, IP:", wlan.ifconfig()[0])
def on_message(topic, msg):
print("Nachricht empfangen:", topic, msg)
if topic == MQTT_TOPIC:
if msg == b"AN":
led_pin.value(1)
print("Pin D12 aktiviert")
elif msg == b"AUS":
led_pin.value(0)
print("Pin D12 deaktiviert")
else:
print("Unbekannter Payload:", msg)
def connect_mqtt():
client = MQTTClient(MQTT_CLIENT_ID, MQTT_BROKER, port=MQTT_PORT)
client.set_callback(on_message)
client.connect()
client.subscribe(MQTT_TOPIC)
print("Mit MQTT-Broker verbunden und Topic abonniert:", MQTT_TOPIC)
return client
def main():
connect_wifi()
client = connect_mqtt()
try:
while True:
client.wait_msg() # blockiert, bis eine Nachricht eintrifft
except Exception as e:
print("Fehler:", e)
finally:
client.disconnect()
if __name__ == "__main__":
main()
MQTT-Nachricht testen
Zum Testen verwende ich den MQTT Explorer. Dort verbinde ich mich mit meinem MQTT-Broker unter der Adresse:
192.168.178.186
Anschließend veröffentliche ich eine Nachricht auf folgendem Topic:
board/output/led
Zum Einschalten der roten LED sende ich den Payload:
AN
Zum Ausschalten der roten LED sende ich den Payload:
AUS
Wenn alles korrekt eingerichtet ist, reagiert der Raspberry Pi Pico 2 W direkt auf die empfangene MQTT-Nachricht und schaltet die rote LED auf dem Funduino Cube entsprechend ein oder aus.
Wichtig: Payload als Bytes vergleichen
Im Programm werden die empfangenen MQTT-Nachrichten als Bytes verarbeitet. Deshalb wird der Payload nicht mit "AN" oder "AUS" verglichen, sondern mit:
b"AN"
und
b"AUS"
Der relevante Teil im Programm sieht daher so aus:
if msg == b"AN":
led_pin.value(1)
elif msg == b"AUS":
led_pin.value(0)
Damit ist die Grundlage für den nächsten Schritt geschaffen. Der Raspberry Pi Pico 2 W empfängt nun MQTT-Nachrichten und kann darauf reagieren. Aktuell senden wir die Befehle noch manuell über den MQTT Explorer.
Im nächsten Abschnitt ersetzen wir diesen manuellen Schritt durch Node-RED. Dort erstellen wir einen einfachen Flow, mit dem die rote LED auf dem Funduino Cube bequem per Schaltfläche gesteuert werden kann.
So wird aus dem ersten MQTT-Test ein kleiner, aber vollständiger IoT-Aufbau:
Node-RED sendet den Befehl, MQTT überträgt die Nachricht und der Pico 2 W schaltet die LED auf dem Funduino Cube.
LED über Node-RED steuern
Nachdem die Steuerung der roten LED über den MQTT Explorer funktioniert hat, ersetzen wir diesen manuellen Schritt nun durch Node-RED.
Dafür verwende ich einen sehr einfachen Flow. Dieser besteht aus zwei Inject-Nodes und einer MQTT-Out-Node.
Die beiden Inject-Nodes dienen dabei als einfache Schalter:
- LED AN sendet den Payload
AN - LED AUS sendet den Payload
AUS
Beide Nachrichten werden auf dasselbe MQTT-Topic gesendet:
board/output/led
Die MQTT-Out-Node stellt anschließend die Verbindung zum MQTT-Broker her. In meinem Fall läuft der Broker unter der IP-Adresse:
192.168.178.186
und verwendet den Standardport:
1883
Der Aufbau ist bewusst einfach gehalten. Es geht in diesem Schritt noch nicht um ein Dashboard oder eine komplexe Automatisierung, sondern darum, den manuellen Test aus dem MQTT Explorer durch einen ersten Node-RED-Flow zu ersetzen.
Aufbau des Node-RED-Flows
Der Flow besteht aus drei wesentlichen Komponenten:
| Node | Aufgabe |
|---|---|
| Inject-Node „LED AN“ | sendet den Payload AN auf das Topic board/output/led |
| Inject-Node „LED AUS“ | sendet den Payload AUS auf das Topic board/output/led |
| MQTT-Out-Node | sendet die MQTT-Nachricht an den Broker |
Wenn der Inject-Node LED AN ausgelöst wird, sendet Node-RED folgende MQTT-Nachricht:
Topic: board/output/ledPayload: AN
Der Raspberry Pi Pico 2 W empfängt diese Nachricht und schaltet die rote LED auf dem Funduino Cube ein.
Beim Inject-Node LED AUS wird entsprechend diese Nachricht gesendet:
Topic: board/output/ledPayload: AUS
Daraufhin schaltet der Pico 2 W die LED wieder aus.
Node-RED-Flow importieren
Den folgenden Flow kannst du direkt in Node-RED importieren:
Node-RED Flow zum Importieren
[
{
"id": "50e37632d620891e",
"type": "tab",
"label": "Funduino Cube",
"disabled": false,
"info": "",
"env": []
},
{
"id": "9ec8dd71740280f3",
"type": "inject",
"z": "50e37632d620891e",
"name": "LED AN",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "board/output/led",
"payload": "AN",
"payloadType": "str",
"x": 130,
"y": 60,
"wires": [
[
"b44962db78a24dfb"
]
]
},
{
"id": "b44962db78a24dfb",
"type": "mqtt out",
"z": "50e37632d620891e",
"name": "",
"topic": "",
"qos": "",
"retain": "",
"respTopic": "",
"contentType": "",
"userProps": "",
"correl": "",
"expiry": "",
"broker": "7eae674d87a425a4",
"x": 290,
"y": 100,
"wires": []
},
{
"id": "8807598632bb2a22",
"type": "inject",
"z": "50e37632d620891e",
"name": "LED AUS",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "board/output/led",
"payload": "AUS",
"payloadType": "str",
"x": 120,
"y": 160,
"wires": [
[
"b44962db78a24dfb"
]
]
},
{
"id": "7eae674d87a425a4",
"type": "mqtt-broker",
"name": "",
"broker": "192.168.178.186",
"port": 1883,
"clientid": "",
"autoConnect": true,
"usetls": false,
"protocolVersion": 4,
"keepalive": 60,
"cleansession": true,
"autoUnsubscribe": true,
"birthTopic": "",
"birthQos": "0",
"birthRetain": "false",
"birthPayload": "",
"birthMsg": {},
"closeTopic": "",
"closeQos": "0",
"closeRetain": "false",
"closePayload": "",
"closeMsg": {},
"willTopic": "",
"willQos": "0",
"willRetain": "false",
"willPayload": "",
"willMsg": {},
"userProps": "",
"sessionExpiry": ""
}
]
Flow in Node-RED testen
Nach dem Import sollte der Flow so aufgebaut sein:
Nach dem Deploy kannst du die beiden Inject-Nodes testen.
Ein Klick auf LED AN sendet den Payload AN an den MQTT-Broker. Der Pico 2 W empfängt die Nachricht und schaltet die rote LED ein.
Ein Klick auf LED AUS sendet den Payload AUS. Die rote LED wird wieder ausgeschaltet.
Damit ist der erste einfache Node-RED-Flow für den Funduino Cube fertig.
Warum dieser Schritt wichtig ist
Dieser Flow ist technisch sehr einfach, aber er zeigt das Grundprinzip sehr gut:
Node-RED sendet einen Befehl, MQTT überträgt die Nachricht und der Raspberry Pi Pico 2 W setzt den Befehl auf dem Funduino Cube um.
Damit haben wir jetzt eine saubere Grundlage für weitere Experimente. Im nächsten Schritt können zusätzliche LEDs, Sensoren oder Aktoren des Funduino Cube eingebunden werden. Aus dem einfachen LED-Test kann so nach und nach ein kleines IoT-Lernprojekt entstehen.
Fazit
Mit der Adapterplatine wird der Funduino Cube deutlich flexibler. Der Raspberry Pi Pico 2 W sitzt sauber auf dem Board, lässt sich mit MicroPython programmieren und kann über WLAN mit einem MQTT-Broker kommunizieren.
Der erste Test mit der roten LED zeigt das Grundprinzip sehr gut:
Zuerst wird die LED direkt per MicroPython geschaltet, danach über MQTT und schließlich über einen einfachen Node-RED-Flow.
Damit ist aus dem Funduino Cube nicht nur ein Arduino-Lernboard geworden, sondern die Grundlage für ein kleines IoT-Lernsystem. Im nächsten Schritt lassen sich weitere LEDs, Sensoren und Aktoren einbinden und über MQTT an Node-RED übertragen.
Häufige Fragen zum Funduino Cube mit Raspberry Pi Pico 2 W, MQTT und Node-RED
Kann ich den Funduino Cube direkt mit einem Arduino Nano ESP32 betreiben?
Mechanisch kann ein Nano-Board je nach Bauform zwar in den Sockel passen, elektrisch ist das aber nicht automatisch eine saubere Lösung. Der Funduino Cube ist für den klassischen Arduino Nano ausgelegt und arbeitet an vielen Stellen im 5V-Umfeld. Viele moderne Boards, darunter auch ESP32-basierte Nano-Boards, arbeiten jedoch mit 3,3V Logik. Genau deshalb verwende ich in diesem Beitrag die passende Adapterplatine für den Raspberry Pi Pico 2 W.
Warum verwende ich den Raspberry Pi Pico 2 W?
Der Raspberry Pi Pico 2 W bringt WLAN mit, lässt sich sehr gut mit MicroPython programmieren und kann über die passende Adapterplatine sauber auf dem Funduino Cube betrieben werden. Damit eignet er sich sehr gut für kleine IoT-Projekte mit MQTT, Node-RED oder später auch weiteren Smart-Home-Anbindungen.
Wofür wird die Adapterplatine benötigt?
Die Adapterplatine sorgt dafür, dass der Raspberry Pi Pico 2 W korrekt mit dem Funduino Cube verbunden wird. Sie bildet die Pinbelegung passend auf den Cube ab und macht den Betrieb mit dem Pico deutlich sauberer als ein direkter Versuch mit einem nicht passenden Nano-kompatiblen Board.
Worauf muss ich beim Aufstecken des Adapters achten?
Auf der Rückseite der Adapterplatine befindet sich ein Hinweis zur richtigen Ausrichtung. Diese Markierung sollte unbedingt beachtet werden. Wird der Adapter falsch herum eingesetzt, können Pins falsch verbunden werden. Im schlimmsten Fall können der Raspberry Pi Pico 2 W, die Adapterplatine oder der Funduino Cube beschädigt werden.
Warum sollte ich vorher ein leeres Programm auf den Pico 2 W spielen?
Wenn der Pico 2 W bereits in einem anderen Projekt verwendet wurde, kann darauf noch ein altes Programm laufen. Dieses Programm könnte beim Start GPIOs schalten oder Signale ausgeben, die auf dem Funduino Cube nicht erwartet werden. Mit einem leeren Programm startest du in einem definierten Zustand und vermeidest unerwartetes Verhalten.
Welche LED wird im Beispiel gesteuert?
In diesem Beitrag wird zunächst die rote LED auf dem Funduino Cube gesteuert. In meinem Aufbau ist diese LED mit GPIO12 des Raspberry Pi Pico 2 W verbunden. Der erste Test erfolgt lokal mit MicroPython, danach wird die LED per MQTT geschaltet.
Welches MQTT-Topic wird verwendet?
Für die Steuerung der LED verwende ich das Topic:
board/output/led
Über dieses Topic empfängt der Raspberry Pi Pico 2 W die Steuerbefehle für die rote LED.
Welche Payloads schalten die LED ein und aus?
Die LED wird über zwei einfache Payloads gesteuert:
AN
schaltet die LED ein.
AUS
schaltet die LED wieder aus.
Im MicroPython-Programm werden diese Werte als Bytes verarbeitet, also zum Beispiel b"AN" und b"AUS".
Brauche ich Node-RED zwingend für diesen Aufbau?
Nein. Für den ersten Test reicht der MQTT Explorer vollkommen aus. Damit kannst du manuell Nachrichten an das Topic senden und prüfen, ob der Pico 2 W korrekt reagiert. Node-RED kommt erst im nächsten Schritt dazu und macht die Steuerung komfortabler, weil du dort eigene Flows und später auch Dashboards oder Automatisierungen aufbauen kannst.
Was ist der nächste sinnvolle Schritt nach der LED-Steuerung?
Nach der einfachen LED-Steuerung kannst du weitere Komponenten des Funduino Cube einbinden. Sinnvoll wären zum Beispiel weitere LEDs, der Taster, der DHT11-Sensor oder der NeoPixel-Ring. Dadurch lässt sich der Cube Schritt für Schritt zu einem kleinen IoT-Lernboard erweitern, das Daten per MQTT sendet und Befehle von Node-RED empfängt.
Letzte Aktualisierung am: 08. Juli 2026
