Raspberry Pi Pico W MQTT mit MicroPython: Sensordaten senden und Befehle empfangen

Raspberry Pi Pico W MQTT Projekte sind ein idealer Einstieg in vernetzte Hardware: Das Board ist günstig, MicroPython ist leicht lesbar, und MQTT bietet einen schlanken Weg, Messwerte in die Cloud zu senden und Befehle zurückzuempfangen. In diesem Tutorial flashen Sie MicroPython, installieren die Bibliothek umqtt.simple, veröffentlichen die Onboard-Temperatur des Pico W alle zehn Sekunden an einen Broker, schalten die Onboard-LED von Ihrem Computer aus und machen das Ganze robust gegen WLAN- und Broker-Abbrüche.

Was Sie brauchen

Ein zusätzlicher Sensor ist nicht nötig. Der RP2040 hat einen internen Temperatursensor auf ADC-Kanal 4, ideal, um den Datenpfad zu prüfen, bevor Sie echte Hardware anschließen. Wenn Sie sich noch zwischen Boards entscheiden, helfen unser Vergleich ESP32 vs. Raspberry Pi Pico W und der Leitfaden Pico W vs. Pico 2 W.

Schritt 1: MicroPython flashen

1. Laden Sie die aktuelle MicroPython-UF2-Datei für den Raspberry Pi Pico W (Board-Name RPI_PICO_W) von der MicroPython-Downloadseite oder aus der MicroPython-Dokumentation von Raspberry Pi herunter. Der Build für den normalen Pico hat keine WLAN-Unterstützung, wählen Sie also unbedingt die W-Variante.
2. Halten Sie die Taste BOOTSEL gedrückt, während Sie das Board per USB anschließen. Es erscheint als Laufwerk namens RPI-RP2.
3. Kopieren Sie die UF2-Datei auf das Laufwerk. Das Board startet automatisch in MicroPython neu.
4. Öffnen Sie Thonny, wählen Sie unten rechts MicroPython (Raspberry Pi Pico) als Interpreter, und Sie sollten den Prompt >>> sehen.

Geben Sie am Prompt import network ein. Funktioniert das ohne Fehler, haben Sie den WLAN-Build.

Schritt 2: umqtt.simple installieren

MicroPython liefert umqtt.simple als Paket in micropython-lib aus, nicht in jedem Firmware-Build. Installieren Sie es, sobald das Board das Internet erreicht, mit mip aus der REPL nach der WLAN-Verbindung:

import network, time, mip
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect("YOUR_WIFI_SSID", "YOUR_WIFI_PASSWORD")
while not wlan.isconnected():
    time.sleep(0.5)
mip.install("umqtt.simple")

Alternativ von Ihrem Computer aus, mit per USB angeschlossenem Board:

pip install mpremote
mpremote mip install umqtt.simple

Thonny bietet außerdem Tools → Manage packages, wo Sie nach umqtt.simple suchen können. Jede der drei Methoden legt die Bibliothek in /lib auf dem Board ab.

Schritt 3: Topics und Client ID planen

Jeder MQTT-Client braucht eine eindeutige, nicht leere Client ID. Der Pico W hat eine eindeutige Board-ID, die wir verwenden können, sodass zwei Boards mit demselben Code nie kollidieren. Für die Topics nutzen wir ein Demo-Präfix mit einer zufälligen Zeichenfolge Ihrer Wahl:

Der kostenlose öffentliche MQTT-Broker unter broker.connectmq.com akzeptiert anonyme Verbindungen auf Port 1883, aber alles, was dort veröffentlicht wird, ist für jeden Abonnenten sichtbar. Verwenden Sie ein eindeutiges Präfix und senden Sie nur Testdaten.

Schritt 4: Das vollständige Raspberry Pi Pico W MQTT-Programm

Speichern Sie es als main.py auf dem Board, damit es beim Booten läuft. Ändern Sie die WLAN-Zugangsdaten und ersetzen Sie pw7c3e durch Ihre eigene Zeichenfolge.

# main.py - Raspberry Pi Pico W MQTT example (MicroPython + umqtt.simple)
import time
import network
import machine
import ubinascii
import rp2
from umqtt.simple import MQTTClient

WIFI_SSID = "YOUR_WIFI_SSID"
WIFI_PASSWORD = "YOUR_WIFI_PASSWORD"
COUNTRY = "GB"                      # Ihr zweistelliger Ländercode

BROKER = "broker.connectmq.com"
PORT = 1883
PREFIX = "connectmq/demo/pw7c3e/pico1"
CLIENT_ID = "pico-" + ubinascii.hexlify(machine.unique_id()).decode()

PUBLISH_INTERVAL_MS = 10_000
KEEPALIVE_S = 60

led = machine.Pin("LED", machine.Pin.OUT)
sensor = machine.ADC(4)


def read_temperature():
    # Interner RP2040-Sensor: 27 C bei 0,706 V, Steigung -1,721 mV/C
    voltage = sensor.read_u16() * 3.3 / 65535
    return round(27 - (voltage - 0.706) / 0.001721, 2)


def connect_wifi():
    rp2.country(COUNTRY)
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    wlan.config(pm=0xA11140)        # Energiesparen aus für eine reaktionsschnelle Verbindung
    if not wlan.isconnected():
        wlan.connect(WIFI_SSID, WIFI_PASSWORD)
        for _ in range(30):
            if wlan.isconnected():
                break
            led.toggle()
            time.sleep(0.5)
    if not wlan.isconnected():
        raise OSError("Wi-Fi connection failed, status %d" % wlan.status())
    print("Wi-Fi connected:", wlan.ifconfig()[0])
    led.off()


def on_message(topic, msg):
    topic = topic.decode()
    msg = msg.decode().strip().upper()
    print("Received", topic, msg)
    if topic == PREFIX + "/led/set":
        if msg in ("ON", "1"):
            led.on()
        elif msg in ("OFF", "0"):
            led.off()
        client.publish(PREFIX + "/led/state", "ON" if led.value() else "OFF", retain=True)


def connect_mqtt():
    c = MQTTClient(CLIENT_ID, BROKER, port=PORT, keepalive=KEEPALIVE_S)
    c.set_last_will(PREFIX + "/status", "offline", retain=True, qos=1)
    c.set_callback(on_message)
    c.connect()
    c.publish(PREFIX + "/status", "online", retain=True, qos=1)
    c.subscribe(PREFIX + "/led/set", qos=1)
    print("MQTT connected as", CLIENT_ID)
    return c


client = None


def main():
    global client
    connect_wifi()
    client = connect_mqtt()
    last_publish = time.ticks_ms() - PUBLISH_INTERVAL_MS
    last_ping = time.ticks_ms()

    while True:
        client.check_msg()                         # eingehende Befehle verarbeiten
        now = time.ticks_ms()

        if time.ticks_diff(now, last_publish) >= PUBLISH_INTERVAL_MS:
            temp = read_temperature()
            payload = '{"value": %s, "unit": "C"}' % temp
            client.publish(PREFIX + "/temperature", payload)
            print("Published", payload)
            last_publish = now
            last_ping = now

        elif time.ticks_diff(now, last_ping) >= (KEEPALIVE_S // 2) * 1000:
            client.ping()                          # Session am Leben halten
            last_ping = now

        time.sleep_ms(100)


while True:
    try:
        main()
    except OSError as e:
        print("Connection problem:", e, "- retrying in 5 s")
        try:
            if client:
                client.disconnect()
        except Exception:
            pass
        time.sleep(5)

Klicken Sie in Thonny auf Run oder setzen Sie das Board zurück. Die Shell sollte die WLAN-Adresse, die MQTT-Verbindung und alle zehn Sekunden einen Publish anzeigen.

So funktioniert das Programm

• Eindeutige Client ID. machine.unique_id() wird aus dem Flash-Chip gelesen, sodass jedes Board automatisch seine eigene ID erhält.
• Last Will. Verschwindet der Pico ohne sauberen Disconnect, veröffentlicht der Broker in seinem Namen offline auf dem Status-Topic. Zusammen mit der retained online-Nachricht sieht jeder Abonnent, ob das Gerät läuft.
• Nicht blockierende Schleife. check_msg() kehrt sofort zurück, wenn nichts zu lesen ist. So kann die Schleife zeitgesteuert veröffentlichen und trotzdem innerhalb von etwa einer Zehntelsekunde auf LED-Befehle reagieren.
• Keepalive-Pings. umqtt.simple pingt nicht automatisch. Ohne die ping()-Aufrufe würde der Broker eine ruhige Verbindung nach Ablauf des Keepalive-Intervalls schließen.
• Reconnect. Jeder Socket-Fehler löst OSError aus; die äußere Schleife wartet fünf Sekunden und beginnt von vorn, bei Bedarf einschließlich WLAN.

Schritt 5: Vom Computer aus testen

Beobachten Sie alles, was der Pico veröffentlicht:

mosquitto_sub -h broker.connectmq.com -p 1883 -i laptop-pw7c3e -v -t "connectmq/demo/pw7c3e/#"

Schalten Sie die LED:

mosquitto_pub -h broker.connectmq.com -p 1883 -i cmd-pw7c3e -t "connectmq/demo/pw7c3e/pico1/led/set" -m "ON"
mosquitto_pub -h broker.connectmq.com -p 1883 -i cmd-pw7c3e -t "connectmq/demo/pw7c3e/pico1/led/set" -m "OFF"

Die LED sollte folgen, und der Abonnent zeigt den neuen Zustand. Ziehen Sie den Pico ab, und nach Ablauf der Keepalive-Zeit erhält der Abonnent offline aus dem Last Will.

Fehlerbehebung

Der Onboard-Sensor reagiert außerdem empfindlich auf die genaue Referenzspannung, sodass die Werte um einige Grad abweichen können. Für dieses Tutorial ist das in Ordnung; für echte Messungen schließen Sie einen DS18B20, BME280 oder SHT31 an.

Von der Demo zur Produktion

Der öffentliche MQTT-Broker ist geteilt und offen, daher sollten produktive Geräte sich mit eigenen Zugangsdaten und TLS verbinden. Bei ConnectMQ legen Sie im Portal einen Broker an und kopieren den generierten Benutzernamen, das Passwort und die Client ID. Client IDs sind an die ausgegebenen Zugangsdaten gebunden. Verwenden Sie deshalb exakt den Wert YOUR_CLIENT_ID aus dem Portal statt der vom Board abgeleiteten ID und übergeben Sie user="YOUR_USERNAME" und password="YOUR_PASSWORD" an MQTTClient. Wechseln Sie dann auf Port 8883 mit Zertifikatsprüfung; das wird Schritt für Schritt in Pico W MQTT über TLS erklärt. Für batteriebetriebene Designs lesen Sie Pico W MQTT im Batteriebetrieb.

Ein verwalteter MQTT-Broker wie ConnectMQ bietet zudem Werkzeuge rund um das Gerät: Mit dem MQTT-Client des Portals im Browser und dem Live-Topic-Explorer prüfen Sie die Topics des Pico, ohne etwas zu installieren, und Schwellwert-Alarmregeln melden eine Temperatur außerhalb des zulässigen Bereichs. Für weitere Raspberry-Pi-Projekte, auch mit den großen Boards, beginnen Sie mit dem Raspberry Pi MQTT Tutorial.

Verbinden Sie Ihren Pico W mit ConnectMQ

Registrieren Sie sich unter app.connectmq.com für den kostenlosen Serverless-Plan, ohne Kreditkarte. Legen Sie einen Broker an, kopieren Sie die Zugangsdaten in main.py, und Ihr Pico W spricht in wenigen Minuten mit einem privaten Broker. Die 25 Verbindungen des kostenlosen Plans reichen für ein ganzes Regal voller Pico-W-Boards.

Häufig gestellte Fragen

Welche MQTT-Bibliothek sollte ich auf dem Pico W verwenden?

umqtt.simple aus micropython-lib ist die Standardwahl für MicroPython. Sie ist klein, unterstützt QoS 0 und 1, Last Will, Retained Messages und TLS und lässt sich mit mip installieren.

Unterstützt der Raspberry Pi Pico W MQTT über TLS?

Ja. Das MicroPython-Modul ssl funktioniert auf dem Pico W, und umqtt.simple kann sich mit Zertifikatsprüfung an Port 8883 verbinden, auch wenn der Handshake spürbar länger dauert als auf Chips mit Kryptobeschleunigung.

Warum trennt sich mein Pico W nach einer Minute vom MQTT-Broker?

umqtt.simple sendet von sich aus keine Keepalive-Pings. Rufen Sie regelmäßig client.ping() auf, mindestens einmal pro Keepalive-Intervall, oder veröffentlichen Sie oft genug, um die Verbindung aktiv zu halten.

Kann ich den Pico W mit Arduino statt MicroPython nutzen?

Ja. Der Arduino-Pico-Core unterstützt das WLAN des Pico W, und Bibliotheken wie PubSubClient funktionieren damit. MicroPython ist beim Prototyping meist schneller, C/C++ bietet mehr Kontrolle über Speicher und Timing.