Ratgeber · 9 Min. Lesezeit

Raspberry Pi Pico W MQTT: Sensor und LED mit umqtt steuern

Raspberry Pi Pico W mit MQTT nutzen: umqtt installieren, kostenlosen Broker wählen, Temperatur senden, LED per Befehl schalten und Home Assistant anbinden.

Raspberry Pi Pico W mit MQTT ist der leichteste und verbreitetste Weg, dein Board ins Internet zu bringen, Sensordaten zu senden und Befehle aus der Ferne zu empfangen. Mit der MicroPython-Bibliothek umqtt.simple verbindet sich der Pico W mit wenigen Zeilen Code mit einem MQTT-Broker, veröffentlicht die gemessene Temperatur in einem Topic und schaltet die LED ein oder aus, sobald auf einem anderen Topic "ON" oder "OFF" eintrifft. Du musst keinen Webserver einrichten, keinen Port im Router freigeben und dir keine IP-Adresse merken: Handy, Computer und Home Assistant sprechen über denselben Broker mit deinem Board.

In dieser Anleitung lernst du zuerst die Logik und die wichtigsten Begriffe von MQTT. Danach installierst du die umqtt-Bibliothek, verbindest dich mit einem kostenlosen öffentlichen Broker, veröffentlichst den Wert des internen Temperatursensors alle zehn Sekunden und steuerst die interne LED aus der Ferne. Zum Schluss machst du den Code so robust, dass er sich bei einem Abbruch der WLAN- oder Broker-Verbindung selbst erholt, und fügst das Board per MQTT Discovery ohne eine einzige Zeile YAML zu Home Assistant hinzu.

Raspberry Pi Pico Mikrocontroller-Board
Raspberry Pi Pico Board. Für MQTT brauchst du die Variante mit Funkchip (Pico W oder Pico 2 W); ein zusätzliches WLAN-Modul ist nicht nötig.

Was ist MQTT und wie funktioniert es?

MQTT (Message Queuing Telemetry Transport) ist ein Publish/Subscribe-Nachrichtenprotokoll für Geräte mit geringer Bandbreite und begrenzter Rechenleistung. In der Mitte steht ein Server, der Broker. Die Geräte verbinden sich nicht direkt miteinander, sondern öffnen jeweils eine TCP-Verbindung zum Broker (Port 1883 unverschlüsselt, 8883 mit TLS). Veröffentlicht ein Gerät eine Nachricht auf einem Topic wie "bluegrays/picow/sicaklik", leitet der Broker sie an alle weiter, die dieses Topic abonniert haben. Der Pico W muss also nicht wissen, wer die Nachricht liest: eine Handy-App, ein Datenlogger und Home Assistant können dieselben Daten gleichzeitig empfangen. Der feste Header eines MQTT-Pakets ist nur 2 Byte groß, deshalb verbraucht MQTT deutlich weniger Daten und Energie als HTTP-Anfragen.

BegriffBedeutungBeispiel
BrokerServer, der Nachrichten annimmt und an Abonnenten verteiltMosquitto, HiveMQ, EMQX
ClientJedes Gerät oder jede App, die sich mit dem Broker verbindetPico W, Handy, Home Assistant
TopicMit / getrennte Adresse, an die eine Nachricht gesendet wirdbluegrays/picow/sicaklik
Publish (veröffentlichen)Eine Nachricht an ein Topic sendenDen Wert "23.4" senden
Subscribe (abonnieren)Nachrichten eines Topics empfangenbluegrays/picow/led
QoSZustellgarantie: 0 höchstens einmal, 1 mindestens einmal, 2 genau einmalumqtt.simple unterstützt 0 und 1
RetainDer Broker speichert die letzte Nachricht und sendet sie neuen Abonnenten sofortLetzter Zustand der LED
Last Will (LWT)Nachricht, die der Broker veröffentlicht, wenn das Gerät unerwartet wegbricht"offline"
KeepaliveMaximale Zeit in Sekunden zwischen zwei Paketen des Clients60

Topics funktionieren wie Ordnerpfade und unterscheiden Groß- und Kleinschreibung. Beim Abonnieren kannst du zwei Platzhalter nutzen: + steht für genau eine Ebene ("ev/+/sicaklik" erfasst sowohl "ev/salon/sicaklik" als auch "ev/mutfak/sicaklik"), # steht für alle restlichen Ebenen und darf nur am Ende stehen ("ev/#"). Beim Veröffentlichen sind Platzhalter nicht erlaubt. Verzichte in Topic-Namen auf Leerzeichen und Sonderzeichen wie Umlaute, dann gibt es weniger Probleme zwischen verschiedenen Clients.

Was du brauchst und wie du den Pico W anschließt

  • Raspberry Pi Pico W oder Pico 2 W: Mit dem normalen Pico ohne Funkchip ist MQTT nicht möglich.
  • MicroPython-Firmware: die .uf2-Datei für die W-Variante. Die Installation steht in Was ist der Raspberry Pi Pico?.
  • Thonny oder ein anderer MicroPython-Editor und ein Micro-USB-Kabel, das Daten überträgt.
  • 2,4-GHz-WLAN: Der Pico W kann sich nicht mit 5-GHz-Netzen verbinden.
  • Ein MQTT-Client: zum Testen MQTT Explorer am Computer oder eine MQTT-Panel-App auf dem Handy.
  • Optional: externe LED mit 220-Ω-Widerstand, ein externer Sensor wie DHT22 oder BME280, ein Relaismodul.
BauteilAnschluss am Pico WHinweis
Interne LEDPin("LED")Wird über den Funkchip angesteuert, nicht über GP25
Interner TemperatursensorADC(4)Kein Kabel nötig; misst die Temperatur des Chips selbst
Externe LEDGP15 → 220 Ω → LED-Anode, Kathode → GNDIm Code Pin(15, Pin.OUT)
DHT22-DatenpinGP16 (VCC → 3V3, GND → GND)Wird mit dem dht-Modul von MicroPython ausgelesen
Relaismodul INGP14Wähle ein Modul, das mit 3,3 V schaltet
Für den Funkchip reservierte PinsGPIO23, 24, 25, 29Nicht herausgeführt, anderweitig nicht nutzbar
Beim normalen Pico hängt die interne LED an GP25, aber beim Pico W wird GP25 für die Kommunikation mit dem Funkchip genutzt. Schreibst du hier Pin(25), leuchtet die LED nicht und du kannst sogar die WLAN-Kommunikation stören. Verwende für die interne LED immer Pin("LED", Pin.OUT). Wenn du eine externe LED anschließt, bestimme den Widerstand für 3,3 V mit dem LED-Vorwiderstandsrechner.

Die umqtt-Bibliothek installieren

  1. Schließe das Board bei gedrückter BOOTSEL-Taste an den Computer an und kopiere die MicroPython-.uf2-Datei für die W-Variante auf das erscheinende Laufwerk RPI-RP2.
  2. Wähle in Thonny unten rechts den Interpreter MicroPython (Raspberry Pi Pico) und gib in der Shell from umqtt.simple import MQTTClient ein. Bekommst du keinen Fehler, ist die Bibliothek schon in der Firmware und du musst nichts installieren.
  3. Bei einem ImportError verbindest du das Board mit dem folgenden Code mit deinem WLAN und lädst die Bibliothek mit mip direkt aus dem Internet.
  4. Alternativ suchst du in Thonny unter Extras > Pakete verwalten nach micropython-umqtt.simple und installierst es.
  5. Danach solltest du im Dateisystem des Pico die Datei /lib/umqtt/simple.py sehen.
Python
1import network
2import time
3import mip
4
5wlan = network.WLAN(network.STA_IF)
6wlan.active(True)
7wlan.connect("WIFI_ADIN", "WIFI_SIFREN")   # kendi ağ bilgilerin / your network credentials
8
9while not wlan.isconnected():
10    print("Baglaniyor... / Connecting...")
11    time.sleep(1)
12
13print("IP:", wlan.ifconfig()[0])
14mip.install("umqtt.simple")                 # /lib/umqtt/simple.py olarak kurulur / installed as /lib/umqtt/simple.py
15mip.install("umqtt.robust")                 # isteğe bağlı / optional
umqtt.robust ist eine kleine Schicht auf umqtt.simple: Bricht die Verbindung beim Veröffentlichen oder Warten auf Nachrichten ab, versucht sie automatisch, sich neu zu verbinden. Bei einer Verbindung mit sauberer Sitzung (Clean Session) erneuert sie die Abonnements aber nicht von selbst. In dieser Anleitung schreiben wir die Wiederverbindung selbst; so können wir auch den Fall prüfen, dass das WLAN weg ist, und die Abonnements jedes Mal neu aufbauen.

Einen kostenlosen MQTT-Broker wählen

Zum Einstieg musst du keinen eigenen Server aufsetzen. Viele Firmen betreiben öffentliche Test-Broker; sie verlangen weder Benutzername noch Passwort, sodass du das Board in wenigen Minuten verbinden und die erste Nachricht senden kannst. Für ein dauerhaftes Projekt ist es am solidesten, Mosquitto auf einem Raspberry Pi, einem alten Computer oder in Home Assistant zu installieren: Die Daten bleiben bei dir zu Hause, und auch wenn das Internet ausfällt, können sich die Geräte im lokalen Netz weiter Nachrichten schicken.

BrokerAdressePortHinweis
HiveMQ öffentlicher Brokerbroker.hivemq.com1883 (TCP)Keine Anmeldung, öffentlich
Eclipse-Mosquitto-Testservertest.mosquitto.org1883 (unverschlüsselt), 8883 (TLS)Keine Anmeldung, öffentlich
EMQX öffentlicher Brokerbroker.emqx.io1883 (TCP), 8883 (TLS)Keine Anmeldung, öffentlich
Mosquitto-Add-on von Home AssistantLokale IP-Adresse von Home Assistant1883Benutzername und Passwort nötig
Dein eigener Mosquitto-ServerIP-Adresse deines Raspberry Pi oder Computers1883Volle Kontrolle, läuft im lokalen Netz
Öffentliche Broker sind für alle zugänglich: Andere können dein Topic ebenfalls abonnieren oder Nachrichten senden. Gib deinem Topic ein eigenes Präfix (zum Beispiel deine Initialen und ein paar zufällige Ziffern), sende keine Passwörter oder persönlichen Daten und steuere über einen öffentlichen Broker keine echten Geräte wie Türschlösser oder Steckdosen.

Schritt für Schritt: Temperatur veröffentlichen, LED abonnieren

Das folgende Programm erledigt vier Dinge: Es verbindet sich mit dem WLAN, meldet sich mit einer eindeutigen Client-ID am Broker an, abonniert das Topic bluegrays/picow/led und veröffentlicht alle zehn Sekunden den Wert des internen Temperatursensors auf bluegrays/picow/sicaklik. Kommt auf dem LED-Topic "ON" an, leuchtet die LED, bei "OFF" geht sie aus, und der neue Zustand wird mit dem Retain-Flag auf einem separaten Topic gemeldet. Speicherst du die Datei in Thonny als main.py auf dem Pico, startet das Programm bei jedem Einschalten automatisch.

MicroPython
1import network
2import time
3import machine
4import binascii
5from machine import Pin, ADC
6from umqtt.simple import MQTTClient
7
8SSID = "WIFI_ADIN"                 # Wi-Fi ağ adın / your Wi-Fi name
9PASSWORD = "WIFI_SIFREN"           # Wi-Fi şifren / your Wi-Fi password
10BROKER = "broker.hivemq.com"       # ücretsiz genel broker / free public broker
11PORT = 1883
12MQTT_USER = None                   # Home Assistant için kullanıcı / user for Home Assistant
13MQTT_PASS = None                   # Home Assistant için şifre / password for Home Assistant
14
15CLIENT_ID = b"picow-" + binascii.hexlify(machine.unique_id())   # benzersiz kimlik / unique client id
16TOPIC_TEMP = b"bluegrays/picow/sicaklik"
17TOPIC_LED = b"bluegrays/picow/led"
18TOPIC_LED_STATE = b"bluegrays/picow/led/durum"
19TOPIC_STATUS = b"bluegrays/picow/durum"
20PUBLISH_MS = 10000                 # 10 saniyede bir yayınla / publish every 10 s
21
22led = Pin("LED", Pin.OUT)          # Pico W dahili LED / Pico W onboard LED
23sensor = ADC(4)                    # dahili sıcaklık sensörü / internal temperature sensor
24wlan = network.WLAN(network.STA_IF)
25client = None
26pending_state = None               # bildirilecek LED durumu / LED state to report
27
28
29def read_temp():
30    voltage = sensor.read_u16() * 3.3 / 65535
31    return 27 - (voltage - 0.706) / 0.001721
32
33
34def wifi_connect():
35    wlan.active(True)
36    if wlan.isconnected():
37        return
38    wlan.connect(SSID, PASSWORD)
39    for _ in range(20):            # en fazla 20 saniye bekle / wait up to 20 s
40        if wlan.isconnected():
41            print("IP:", wlan.ifconfig()[0])
42            return
43        time.sleep(1)
44    raise OSError("Wi-Fi baglanamadi / Wi-Fi failed")
45
46
47def on_message(topic, msg):
48    global pending_state
49    print("Mesaj / Message:", topic, msg)
50    if topic == TOPIC_LED:
51        if msg == b"ON":
52            led.on()
53            pending_state = b"ON"
54        elif msg == b"OFF":
55            led.off()
56            pending_state = b"OFF"
57
58
59def mqtt_connect():
60    c = MQTTClient(CLIENT_ID, BROKER, port=PORT, user=MQTT_USER,
61                   password=MQTT_PASS, keepalive=60)
62    c.set_callback(on_message)
63    c.set_last_will(TOPIC_STATUS, b"offline", retain=True)   # koparsa broker yayınlar / broker sends it on drop
64    try:
65        c.connect()
66    except Exception:
67        try:
68            c.sock.close()         # yarım kalan soketi kapat / close the half-open socket
69        except Exception:
70            pass
71        raise
72    c.subscribe(TOPIC_LED)
73    c.publish(TOPIC_STATUS, b"online", retain=True)
74    return c
75
76
77def reconnect():
78    global client
79    delay = 2
80    while True:
81        if client:
82            try:
83                client.sock.close()
84            except Exception:
85                pass
86        try:
87            wifi_connect()
88            client = mqtt_connect()
89            print("MQTT bagli / connected")
90            return
91        except Exception as e:
92            print("Tekrar denenecek / retrying:", e)
93            time.sleep(delay)
94            delay = min(delay * 2, 60)     # üstel bekleme / exponential backoff
95
96
97reconnect()
98last_pub = time.ticks_add(time.ticks_ms(), -PUBLISH_MS)   # ilk yayın hemen / first publish right away
99
100while True:
101    try:
102        client.check_msg()                 # gelen mesaj var mı? / any incoming message?
103        if pending_state:
104            client.publish(TOPIC_LED_STATE, pending_state, retain=True)
105            pending_state = None
106        if time.ticks_diff(time.ticks_ms(), last_pub) >= PUBLISH_MS:
107            last_pub = time.ticks_ms()
108            temp = "{:.1f}".format(read_temp())
109            client.publish(TOPIC_TEMP, temp.encode())
110            print("Yayinlandi / Published:", temp)
111    except Exception as e:
112        print("Baglanti koptu / Connection lost:", e)
113        reconnect()
114    time.sleep_ms(100)
CodeteilWas er macht
CLIENT_IDErzeugt mit machine.unique_id() eine Kennung pro Board; zwei Geräte mit gleicher Kennung werfen sich am Broker gegenseitig raus
read_temp()Wandelt den ADC(4)-Wert in Spannung und mit der Formel 27 - (V - 0,706) / 0,001721 in Grad Celsius um
set_last_will()Sorgt dafür, dass der Broker bei unerwartetem Abbruch "offline" ins Status-Topic schreibt; muss vor connect() aufgerufen werden
subscribe()Beginnt, das LED-Topic zu überwachen; wird bei jeder neuen Verbindung erneut aufgerufen
check_msg()Ruft on_message auf, wenn eine Nachricht da ist, und kehrt sonst sofort zurück
pending_stateStatt im Callback zu veröffentlichen, wird der Zustand in einer Variable abgelegt und die Hauptschleife veröffentlicht
ticks_diff()Misst die zehn Sekunden ohne sleep-Blockade, damit LED-Befehle ohne Verzögerung verarbeitet werden
reconnect()Versucht WLAN und MQTT im Abstand von 2, 4, 8 … höchstens 60 Sekunden neu zu verbinden

Nach dem Start verbindest du dich am Computer mit MQTT Explorer mit demselben Broker und abonnierst bluegrays/picow/#. Du solltest alle zehn Sekunden einen Temperaturwert sehen und im Status-Topic "online". Zum Testen der LED veröffentlichst du auf bluegrays/picow/led in Großbuchstaben ON; die grüne LED auf dem Board leuchtet sofort, und in der Thonny-Shell wird die empfangene Nachricht ausgegeben. Sind die Mosquitto-Client-Tools installiert, geht das auch über die Kommandozeile mit mosquitto_pub -h broker.hivemq.com -t bluegrays/picow/led -m ON. Da der interne Sensor die Temperatur des Chips misst, kann der Wert einige Grad von der Raumtemperatur abweichen; für echte Umgebungsmessungen schließt du einen externen Sensor wie DHT11/DHT22 oder BME280 an und passt read_temp() entsprechend an.

Abgebrochene Verbindungen automatisch wiederherstellen

Der größte Feind eines IoT-Geräts zu Hause sind Verbindungsabbrüche: Der Router startet neu, das WLAN-Signal wird schwach oder der Broker wird gewartet. umqtt.simple erholt sich in diesem Fall nicht von selbst; beim nächsten Aufruf von publish() oder check_msg() wird ein OSError ausgelöst. Der try/except-Block im Programm fängt diesen Fehler ab und ruft reconnect() auf. Die Funktion schließt zuerst den alten Socket, verbindet bei Bedarf das WLAN neu und baut dann MQTT-Verbindung und Abonnement von vorn auf. Nach jedem fehlgeschlagenen Versuch verdoppelt sich die Wartezeit (2, 4, 8, 16, 32, 60 Sekunden); das nennt man exponentielles Backoff und verhindert, dass du den Broker mit Dutzenden Versuchen pro Sekunde überlastest.

Auch der Keepalive-Wert ist wichtig. Im Code haben wir 60 Sekunden gesetzt; nach den MQTT-Regeln trennt der Broker die Verbindung, wenn er das Anderthalbfache dieser Zeit (also 90 Sekunden) kein Paket vom Client erhält. Da wir alle zehn Sekunden veröffentlichen, gibt es kein Problem. Erhöhst du das Intervall aber zum Beispiel auf fünf Minuten, musst du regelmäßig client.ping() aufrufen; umqtt.simple sendet kein Ping-Paket automatisch. Dank der Last-Will-Nachricht schreibt der Broker nach Ablauf des Keepalive "offline" ins Status-Topic, selbst wenn du das Board einfach abziehst, und Home Assistant zeigt das Gerät als "nicht verfügbar" an.

  • Speichere WLAN-Daten und Broker-Passwort in einer separaten Datei secrets.py und gib diese Datei nicht weiter, wenn du den Code teilst.
  • Richte für mehr Stabilität mit machine.WDT(timeout=8000) einen Watchdog ein und rufe in der Hauptschleife regelmäßig wdt.feed() auf; hängt das Programm irgendwo, startet sich das Board neu. Halte dann auch die Wartezeiten in reconnect() unter 8 Sekunden oder füttere den Watchdog beim Warten.
  • Veröffentliche Messwerte nicht in jedem Schleifendurchlauf, sondern in festen Abständen; mittle mehrere Messungen, um Schwankungen zu glätten (Sensordaten filtern).
  • Nutze Retain bei Topics, bei denen der letzte Wert wichtig ist, etwa dem LED-Zustand; sende aber keine Retain-Nachrichten an Befehls-Topics, sonst führt das Board bei jeder Wiederverbindung den alten Befehl erneut aus.
  • Bricht die Verbindung oft ab, probiere mit wlan.config(pm=0xa11140) den Energiesparmodus des Funkchips abzuschalten; das verringert die Latenz, erhöht aber den Stromverbrauch.

Den Pico W mit Home Assistant verbinden

  1. Installiere und starte in Home Assistant unter Einstellungen > Add-ons das Add-on Mosquitto broker.
  2. Lege unter Einstellungen > Personen einen eigenen Benutzer für den Pico W an (zum Beispiel "pico"); für die MQTT-Verbindung werden Benutzername und Passwort dieses Benutzers verwendet.
  3. Richte unter Einstellungen > Geräte & Dienste die automatisch erkannte MQTT-Integration ein.
  4. Ersetze im Code den Wert von BROKER durch die lokale IP-Adresse von Home Assistant (zum Beispiel 192.168.1.50) und trage Benutzername und Passwort in MQTT_USER und MQTT_PASS ein.
  5. Füge die folgende Funktion ha_discovery() in den Code ein und rufe sie in mqtt_connect() nach der subscribe()-Zeile als ha_discovery(c) auf.
  6. Nach wenigen Sekunden erscheint in der Geräteliste ein neues Gerät namens "Pico W" mit dem Temperatursensor und dem LED-Schalter.
MicroPython
1import json
2import binascii
3import machine
4
5DEVICE_ID = "picow_" + binascii.hexlify(machine.unique_id()).decode()
6DEVICE = {
7    "identifiers": [DEVICE_ID],
8    "name": "Pico W",
9    "manufacturer": "Raspberry Pi",
10    "model": "Pico W",
11}
12
13
14def ha_discovery(c):
15    temp_cfg = {
16        "name": "Sicaklik",
17        "unique_id": DEVICE_ID + "_temp",
18        "state_topic": "bluegrays/picow/sicaklik",
19        "unit_of_measurement": "°C",
20        "device_class": "temperature",
21        "availability_topic": "bluegrays/picow/durum",
22        "device": DEVICE,
23    }
24    led_cfg = {
25        "name": "LED",
26        "unique_id": DEVICE_ID + "_led",
27        "command_topic": "bluegrays/picow/led",
28        "state_topic": "bluegrays/picow/led/durum",
29        "payload_on": "ON",
30        "payload_off": "OFF",
31        "availability_topic": "bluegrays/picow/durum",
32        "device": DEVICE,
33    }
34    base = DEVICE_ID.encode()
35    # JSON'u bytes olarak gönder (°C çok baytlıdır) / send JSON as bytes (°C is multi-byte)
36    c.publish(b"homeassistant/sensor/" + base + b"/temp/config",
37              json.dumps(temp_cfg).encode(), retain=True)
38    c.publish(b"homeassistant/switch/" + base + b"/led/config",
39              json.dumps(led_cfg).encode(), retain=True)
40
41# mqtt_connect() içinde subscribe() satırından sonra çağır / call after subscribe() in mqtt_connect()
42# ha_discovery(c)

Home Assistant lauscht standardmäßig auf Topics mit dem Präfix homeassistant/. Sendet der Pico W dorthin mit Retain-Flag eine JSON-Konfiguration, legt Home Assistant die Entitäten automatisch an: Die Sensor-Konfiguration zeigt die Temperatur als grafisch darstellbaren Wert, die Switch-Konfiguration fügt der Oberfläche einen Ein/Aus-Schalter hinzu. Tippst du den Schalter an, veröffentlicht Home Assistant "ON" oder "OFF" auf dem command_topic, das Board schaltet die LED und schreibt den neuen Zustand auf das state_topic; so zeigt der Schalter immer den tatsächlichen Zustand. Das Feld availability_topic nutzt die Last-Will-Nachricht und zeigt die Entitäten ausgegraut, wenn das Board ausgeschaltet ist. Dieselbe Struktur für den ESP32 findest du in ESP32 MQTT und Home Assistant.

Projektideen mit Pico W und MQTT

  • Dashboard für Raumtemperatur und Luftfeuchtigkeit: Stelle in jeden Raum einen Pico W mit DHT22 und behalte das ganze Haus mit Topics wie ev/salon/sicaklik auf einem Bildschirm im Blick.
  • Ferngesteuerte Lampe: Steuere statt der LED ein Relaismodul an und schalte die Lampe über Home Assistant ein und aus.
  • Benachrichtigung zum Gießen: Veröffentliche den Wert des Bodenfeuchtesensors und lass dir per Automation eine Handy-Nachricht senden, wenn die Erde trocken ist.
  • Bewegungsalarm: Veröffentliche eine Nachricht auf ev/koridor/hareket, wenn der PIR-Sensor auslöst.
  • Aquarium-Thermometer: Miss die Wassertemperatur mit dem DS18B20 und sende bei Überschreiten eines Grenzwerts eine Warnung mit Retain.
  • Vergleich mit einer Weboberfläche: Steuere dieselbe LED zusätzlich mit einem Pico-W-Webserver und sieh dir den Unterschied der beiden Methoden an.

Häufige Fehler und ihre Lösungen

SymptomMögliche UrsacheLösung
ImportError: no module named 'umqtt'Die Bibliothek ist nicht in der Firmwaremip.install("umqtt.simple") oder Thonnys Paketverwaltung
WLAN verbindet sich nicht5-GHz-Netz, falsches Passwort oder schwaches Signal2,4-GHz-Netz verwenden, wlan.status() ausgeben, Board näher an den Router bringen
OSError bei connect()Broker-Adresse nicht auflösbar oder keine NetzwerkverbindungZuerst wlan.isconnected() prüfen, Broker-Name und Port korrekt eintragen
MQTTException: 4 oder 5Benutzername oder Passwort falsch, keine BerechtigungBenutzer und Passwort von Home Assistant prüfen
Verbindung bricht nach etwa 90 Sekunden abInnerhalb des Keepalive wird kein Paket gesendetRegelmäßig veröffentlichen oder client.ping() ergänzen
Es kommen keine Nachrichten ancheck_msg() wird nicht in der Schleife aufgerufen oder set_callback() fehltset_callback() vor subscribe() aufrufen, in der Schleife check_msg() verwenden
Der Vergleich ist immer falschTopic und Nachricht kommen als bytes, du vergleichst mit strBytes-Konstanten wie b"ON" verwenden
Zwei Boards werfen sich ständig rausDieselbe CLIENT_ID wird verwendetMit machine.unique_id() eine eindeutige ID erzeugen
Teste die Kette beim Debuggen Stück für Stück: Gibt wlan.isconnected() in der Shell True zurück? Erscheint die im MQTT Explorer veröffentlichte Nachricht auf dem Pico? Kommt die Veröffentlichung des Pico im MQTT Explorer an? Mit diesen drei Schritten findest du in Minuten heraus, ob das Problem beim WLAN, beim Broker oder im Code liegt. Für allgemeine WLAN-Tipps gilt die Checkliste in ESP32 verbindet sich nicht mit WLAN weitgehend auch für den Pico W.

Hast du MQTT einmal eingerichtet, bedeutet jeder neue Sensor oder Ausgang am Board nur ein weiteres Topic; die Infrastruktur bleibt gleich. Lass zuerst das Programm aus dieser Anleitung mit interner LED und Temperatursensor laufen und erweitere es dann um Relais und externe Sensoren. Wenn du MicroPython-Grundlagen wie LED, Taster und PWM vertiefen möchtest, findest du in den Raspberry-Pi-Pico-Projekten der BlueGrays-App zu jedem Schritt Schaltplan und Code.

Häufige Fragen

Kann ich MQTT mit dem normalen Raspberry Pi Pico nutzen?

Nein, der normale Pico hat weder WLAN noch Ethernet und kann sich deshalb nicht direkt mit einem Broker verbinden. Für MQTT brauchst du den Pico W oder Pico 2 W mit Funkchip. Der normale Pico kommt nur mit einem externen WLAN- oder Ethernet-Modul ins Netz, was den Aufbau deutlich komplizierter macht.

Was ist der Unterschied zwischen umqtt.simple und umqtt.robust?

umqtt.simple ist ein sehr kleiner Client für die Grundfunktionen von MQTT wie Verbinden, Veröffentlichen und Abonnieren und löst bei einem Verbindungsabbruch einen Fehler aus. umqtt.robust baut darauf auf und versucht im Fehlerfall automatisch, sich neu zu verbinden. Da es die Abonnements nicht von selbst erneuert, musst du nach der Wiederverbindung subscribe() trotzdem selbst aufrufen.

Welcher ist der beste kostenlose MQTT-Broker?

Zum Testen sind broker.hivemq.com, test.mosquitto.org und broker.emqx.io öffentliche Broker ohne Anmeldung auf Port 1883. Da sie für alle offen sind, solltest du dort nur Testdaten senden. Für eine dauerhafte und sichere Lösung ist Mosquitto auf einem Raspberry Pi oder in Home Assistant die beste kostenlose Option.

Wie füge ich den Pico W zu Home Assistant hinzu?

Installiere in Home Assistant das Mosquitto-Add-on und die MQTT-Integration und lege einen eigenen Benutzer für den Pico W an. Verbinde das Board mit diesem Benutzer mit der IP-Adresse von Home Assistant und veröffentliche eine Discovery-Konfiguration mit Retain auf Topics, die mit homeassistant/ beginnen. Home Assistant legt Sensor und Schalter dann automatisch an.

Warum bricht die MQTT-Verbindung beim Pico W ab?

Die häufigste Ursache ist, dass innerhalb der Keepalive-Zeit kein Paket gesendet wird; umqtt.simple schickt kein Ping automatisch, daher brauchst du regelmäßig client.ping() oder Veröffentlichungen. Auch schwaches WLAN, ein Router-Neustart oder ein zweites Gerät mit derselben Client-ID führen zu Abbrüchen. Schreibst du den Code so, dass er OSError abfängt und sich neu verbindet, löst das all diese Fälle.

Kann ich MQTT mit TLS (Port 8883) auf dem Pico W nutzen?

Ja. Über den Parameter ssl der umqtt.simple-Bibliothek kannst du auf Port 8883 eine verschlüsselte Verbindung aufbauen; in aktuellen MicroPython-Versionen übergibst du dazu einen mit ssl.SSLContext erstellten Kontext. Der TLS-Handshake kann auf dem RP2040 einige Sekunden dauern und erhöht den RAM-Verbrauch. Cloud-Broker wie HiveMQ Cloud verlangen in der Regel eine TLS-Verbindung.

Alle Projekte ansehen
Raspberry Pi Pico Onboard-LED Blinken (Pico und Pico W)
PI-1Anfänger

Raspberry Pi Pico Onboard-LED Blinken (Pico und Pico W)

Das Auftaktprojekt der Raspberry-Pi-Pico-Reihe! Wir lassen die grüne eingebaute LED des Pico blinken und prüfen so, ob das Board funktioniert: das klassische "Hello World" als erstes Experiment. Keine externen Bauteile nötig, nur der Pico und ein USB-Kabel. Der Code ist in MicroPython geschrieben, der Sprache, die die Raspberry Pi Foundation offiziell unterstützt.

5.0(1)
10
Raspberry Pi Pico: Externe LED zum Leuchten bringen (Steckbrett)
PI-2Anfänger

Raspberry Pi Pico: Externe LED zum Leuchten bringen (Steckbrett)

Der nächste Schritt nach der eingebauten LED des Pico: eine externe LED auf dem Steckbrett anschließen und über Pin GP14 steuern. Du lernst, jeden GPIO-Pin des Pico als Ausgang zu nutzen, die Polung der LED (langes Bein = Anode/+, kurzes Bein = Kathode/–) und warum ein Vorwiderstand (220Ω) Pflicht ist. Ohne ihn fließt zu viel Strom durch die LED und sie kann durchbrennen.

4.5(2)
7
Raspberry Pi Pico Taster-gesteuerte LED (Push)
PI-9Anfänger
Premium

Raspberry Pi Pico Taster-gesteuerte LED (Push)

Erstes Eingabe-Projekt mit Pico — Taster lesen! LED leuchtet solange der Taster gedrückt ist. Lerne Pin.IN, Pin.PULL_UP und button.value(). GP14 LED, GP2 Taster mit internem PULL_UP. Gedrückt = 0, losgelassen = 1 — Standard.

11
Raspberry Pi Pico Taster Toggle LED
PI-10Anfänger

Raspberry Pi Pico Taster Toggle LED

Taster + LED — nächste Stufe! Anders als beim einfachen Taster-Projekt musst du den Taster nicht halten. Drücken und loslassen → LED an. Nochmal drücken → LED aus (toggle). Gleiche Schaltung, aber großer Codeunterschied. Lerne Edge Detection, State Tracking und Debounce.

10
Raspberry Pi Pico PWM LED Fade (Atem-Effekt)
PI-14Anfänger

Raspberry Pi Pico PWM LED Fade (Atem-Effekt)

Die LED blinkt nicht mehr nur — sie atmet! Mit der PWM (Pulsweitenmodulation) des Raspberry Pi Pico steigt die Helligkeit langsam an und fällt wieder ab. Lerne die machine.PWM-Klasse, duty_u16() (16-Bit-Helligkeit 0–65535), PWM-Frequenz, range()-Schleifen und analogähnliche Ausgabe. Grundlage für RGB-Farbmischung, Motorsteuerung, Servos und Buzzer.

4
Raspberry Pi Pico RGB-LED Farbwechsel (3-Kanal-PWM)
PI-15Anfänger

Raspberry Pi Pico RGB-LED Farbwechsel (3-Kanal-PWM)

Eine LED, Millionen Farben! Eine RGB-LED enthält 3 LEDs: Rot, Grün und Blau. Mit je einem PWM-Kanal des Pico mischst du Farben: Rot + Grün = Gelb, Grün + Blau = Cyan, alle drei = Weiß. Die LED wechselt durch 8 Farben. Lerne mehrere PWM-Kanäle, Funktionen (def), RGB-Farbmischung, 8-Bit → 16-Bit-Umrechnung (x257) und gemeinsame Kathode vs. Anode.

6
ESP32-WLAN-STA-Verbindung (mit LCD-Display)
ES-25Fortgeschritten

ESP32-WLAN-STA-Verbindung (mit LCD-Display)

In diesem Projekt verbinden wir den ESP32 im Station-Modus (STA) sicher und fehlertolerant mit dem heimischen WLAN. Wir lagern SSID und Passwort in eine separate secrets.h-Datei aus, um Leaks zu Git zu verhindern, richten einen Auto-Reconnect-Mechanismus ein und zeigen RSSI-Signalpegel und IP-Adresse auf einem I2C-LCD-Display an. Die interne LED dient als Statusanzeige. Ein Verbindungsmanager auf Produktionsniveau.

4.4(21)
38
ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
ES-27Fortgeschritten

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)

Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

4.8(16)
26