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.

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.
| Begriff | Bedeutung | Beispiel |
|---|---|---|
| Broker | Server, der Nachrichten annimmt und an Abonnenten verteilt | Mosquitto, HiveMQ, EMQX |
| Client | Jedes Gerät oder jede App, die sich mit dem Broker verbindet | Pico W, Handy, Home Assistant |
| Topic | Mit / getrennte Adresse, an die eine Nachricht gesendet wird | bluegrays/picow/sicaklik |
| Publish (veröffentlichen) | Eine Nachricht an ein Topic senden | Den Wert "23.4" senden |
| Subscribe (abonnieren) | Nachrichten eines Topics empfangen | bluegrays/picow/led |
| QoS | Zustellgarantie: 0 höchstens einmal, 1 mindestens einmal, 2 genau einmal | umqtt.simple unterstützt 0 und 1 |
| Retain | Der Broker speichert die letzte Nachricht und sendet sie neuen Abonnenten sofort | Letzter Zustand der LED |
| Last Will (LWT) | Nachricht, die der Broker veröffentlicht, wenn das Gerät unerwartet wegbricht | "offline" |
| Keepalive | Maximale Zeit in Sekunden zwischen zwei Paketen des Clients | 60 |
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.
| Bauteil | Anschluss am Pico W | Hinweis |
|---|---|---|
| Interne LED | Pin("LED") | Wird über den Funkchip angesteuert, nicht über GP25 |
| Interner Temperatursensor | ADC(4) | Kein Kabel nötig; misst die Temperatur des Chips selbst |
| Externe LED | GP15 → 220 Ω → LED-Anode, Kathode → GND | Im Code Pin(15, Pin.OUT) |
| DHT22-Datenpin | GP16 (VCC → 3V3, GND → GND) | Wird mit dem dht-Modul von MicroPython ausgelesen |
| Relaismodul IN | GP14 | Wähle ein Modul, das mit 3,3 V schaltet |
| Für den Funkchip reservierte Pins | GPIO23, 24, 25, 29 | Nicht herausgeführt, anderweitig nicht nutzbar |
Die umqtt-Bibliothek installieren
- 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.
- 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.
- 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.
- Alternativ suchst du in Thonny unter Extras > Pakete verwalten nach micropython-umqtt.simple und installierst es.
- Danach solltest du im Dateisystem des Pico die Datei /lib/umqtt/simple.py sehen.
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ı / optionalEinen 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.
| Broker | Adresse | Port | Hinweis |
|---|---|---|---|
| HiveMQ öffentlicher Broker | broker.hivemq.com | 1883 (TCP) | Keine Anmeldung, öffentlich |
| Eclipse-Mosquitto-Testserver | test.mosquitto.org | 1883 (unverschlüsselt), 8883 (TLS) | Keine Anmeldung, öffentlich |
| EMQX öffentlicher Broker | broker.emqx.io | 1883 (TCP), 8883 (TLS) | Keine Anmeldung, öffentlich |
| Mosquitto-Add-on von Home Assistant | Lokale IP-Adresse von Home Assistant | 1883 | Benutzername und Passwort nötig |
| Dein eigener Mosquitto-Server | IP-Adresse deines Raspberry Pi oder Computers | 1883 | Volle Kontrolle, läuft im lokalen Netz |
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.
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)| Codeteil | Was er macht |
|---|---|
| CLIENT_ID | Erzeugt 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_state | Statt 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
- Installiere und starte in Home Assistant unter Einstellungen > Add-ons das Add-on Mosquitto broker.
- 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.
- Richte unter Einstellungen > Geräte & Dienste die automatisch erkannte MQTT-Integration ein.
- 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.
- 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.
- Nach wenigen Sekunden erscheint in der Geräteliste ein neues Gerät namens "Pico W" mit dem Temperatursensor und dem LED-Schalter.
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
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| ImportError: no module named 'umqtt' | Die Bibliothek ist nicht in der Firmware | mip.install("umqtt.simple") oder Thonnys Paketverwaltung |
| WLAN verbindet sich nicht | 5-GHz-Netz, falsches Passwort oder schwaches Signal | 2,4-GHz-Netz verwenden, wlan.status() ausgeben, Board näher an den Router bringen |
| OSError bei connect() | Broker-Adresse nicht auflösbar oder keine Netzwerkverbindung | Zuerst wlan.isconnected() prüfen, Broker-Name und Port korrekt eintragen |
| MQTTException: 4 oder 5 | Benutzername oder Passwort falsch, keine Berechtigung | Benutzer und Passwort von Home Assistant prüfen |
| Verbindung bricht nach etwa 90 Sekunden ab | Innerhalb des Keepalive wird kein Paket gesendet | Regelmäßig veröffentlichen oder client.ping() ergänzen |
| Es kommen keine Nachrichten an | check_msg() wird nicht in der Schleife aufgerufen oder set_callback() fehlt | set_callback() vor subscribe() aufrufen, in der Schleife check_msg() verwenden |
| Der Vergleich ist immer falsch | Topic und Nachricht kommen als bytes, du vergleichst mit str | Bytes-Konstanten wie b"ON" verwenden |
| Zwei Boards werfen sich ständig raus | Dieselbe CLIENT_ID wird verwendet | Mit machine.unique_id() eine eindeutige ID erzeugen |
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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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.

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.

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.

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.

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.

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.

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.

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.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

