Raspberry Pi MQTT Tutorial: Veröffentlichen, abonnieren und automatisieren mit Python

Dieses Raspberry Pi MQTT Tutorial bringt Sie von einer frischen Raspberry-Pi-OS-Installation zu einem Python-Programm, das Sensorwerte veröffentlicht, auf Befehle hört und einen GPIO-Pin von überall aus schaltet. Sie testen alles gegen den kostenlosen öffentlichen MQTT-Broker unter broker.connectmq.com und übertragen denselben Code dann mit wenigen Umgebungsvariablen auf einen privaten, per TLS gesicherten Broker. Dabei lernen Sie die Muster kennen, die ein IoT-Gerät auf Pi-Basis monatelang zuverlässig laufen lassen, nicht nur minutenlang.

Was Sie bauen

Am Ende dieses Leitfadens führt Ihr Raspberry Pi einen einzigen Python-Dienst aus, der vier Dinge erledigt:

1. Er verbindet sich mit einem MQTT-Broker und baut die Verbindung nach WLAN-Abbrüchen oder Neustarts automatisch wieder auf.
2. Er veröffentlicht alle zehn Sekunden eine JSON-Telemetrienachricht mit CPU-Temperatur, Load Average und optional einem Raumsensor.
3. Er abonniert ein Befehls-Topic und schaltet eine LED (oder ein Relais) an GPIO17.
4. Er veröffentlicht einen Retained-Status online/offline und nutzt einen MQTT Last Will, damit andere Clients wissen, wann der Pi verschwindet.

Das Topic-Layout hält alles unter einem eindeutigen Präfix, was auf einem geteilten öffentlichen Broker wichtig ist:

Wenn Begriffe wie Topic, Retained Message oder Last Will neu für Sie sind, überfliegen Sie vor dem Start was ein MQTT-Broker leistet. Kurz gesagt: Der Broker ist ein Postamt, Ihr Pi und Ihr Laptop sind Clients, und Topics sind die Adressen.

Voraussetzungen

Für dieses Raspberry Pi MQTT Tutorial brauchen Sie sehr wenig Hardware:

• Einen beliebigen Raspberry Pi mit Netzwerk: Pi 3, Pi 4, Pi 5 oder Zero 2 W. Der Code ist auf allen identisch.
• Raspberry Pi OS Bookworm (Lite genügt) mit aktiviertem SSH und Netzwerkzugang.
• Eine LED mit 330-Ohm-Widerstand oder ein Relaismodul an GPIO17 (physischer Pin 11) und GND (Pin 9). Ohne sie läuft der Code trotzdem und protokolliert nur die Befehle.
• Optional: einen DHT22- oder DS18B20-Sensor. Wir beginnen mit der eingebauten CPU-Temperatur, sodass nichts Zusätzliches nötig ist.
• Einen zweiten Rechner mit mosquitto_sub und mosquitto_pub zum Testen (installieren Sie mosquitto-clients unter Linux oder nutzen Sie Homebrew unter macOS).

Sie vergleichen Boards vor dem Kauf? Unsere Gegenüberstellung Raspberry Pi vs. ESP32 erklärt, wann ein vollwertiger Linux-Rechner einen Mikrocontroller schlägt und wann er überdimensioniert ist.

Schritt 1: Python auf dem Raspberry Pi vorbereiten

Bookworm schützt das System-Python, daher schlägt pip install außerhalb einer virtuellen Umgebung mit dem Fehler „externally managed environment“ fehl. Das ist gut so: Eine virtuelle Umgebung hält die Abhängigkeiten Ihres Projekts isoliert und reproduzierbar. Legen Sie eine in einem Projektordner an:

sudo apt update
sudo apt install -y python3-venv python3-lgpio mosquitto-clients
mkdir -p ~/pi-mqtt && cd ~/pi-mqtt
python3 -m venv --system-site-packages .venv
source .venv/bin/activate
pip install "paho-mqtt>=2.0" gpiozero

Das Flag --system-site-packages lässt die virtuelle Umgebung das per apt installierte Paket lgpio sehen, das gpiozero auf aktuellem Raspberry Pi OS als Pin-Backend nutzt (und das auf dem Pi 5 erforderlich ist, wo die ältere Bibliothek RPi.GPIO nicht funktioniert). Die Pinbelegung Ihres Modells finden Sie in der offiziellen Raspberry-Pi-GPIO-Dokumentation.

Prüfen Sie die installierte Client-Version. Dieser Leitfaden nutzt die Callback-API von paho-mqtt 2.x, die sich von älteren Tutorials im Netz unterscheidet:

python -c "import paho.mqtt; print(paho.mqtt.__version__)"

Schritt 2: Ihr erstes Publish und Subscribe

Bevor Sie das vollständige Programm schreiben, prüfen Sie, ob der Netzwerkpfad funktioniert. Wählen Sie eine zufällige Geräte-ID, damit Ihre Topics nicht mit denen anderer auf dem öffentlichen Broker kollidieren. Abonnieren Sie in einem Terminal (auf Ihrem Laptop oder dem Pi):

mosquitto_sub -h broker.connectmq.com -p 1883 -i sub-laptop-7f3a -v -t "connectmq/demo/pi-7f3a/#"

Veröffentlichen Sie in einem zweiten Terminal eine Testnachricht:

mosquitto_pub -h broker.connectmq.com -p 1883 -i pub-pi-7f3a -t "connectmq/demo/pi-7f3a/hello" -m "hello from the pi"

Der Subscriber gibt Topic und Nachricht sofort aus. Jeder Client braucht eine nicht leere, eindeutige Client ID; teilen sich zwei Clients eine ID, trennt der Broker den älteren, und Sie sehen eine verwirrende Connect-Disconnect-Schleife. Der kostenlose öffentliche MQTT-Broker ist für Tests und Prototypen gedacht und für jeden lesbar, der Ihr Topic errät; senden Sie also niemals Passwörter, personenbezogene Daten oder etwas, das Sie nicht öffentlich posten würden.

Schritt 3: Der vollständige Python-MQTT-Client

Speichern Sie Folgendes als ~/pi-mqtt/pi_mqtt.py. Das Skript liest alle Einstellungen aus Umgebungsvariablen, sodass dieselbe Datei heute für den öffentlichen Broker und später für einen privaten Broker funktioniert.

#!/usr/bin/env python3
"""Raspberry Pi MQTT client: telemetry, GPIO control and online status."""
import json
import os
import signal
import ssl
import threading
import time
import uuid

import paho.mqtt.client as mqtt

try:
    from gpiozero import LED
    led = LED(int(os.getenv("LED_PIN", "17")))
except Exception as exc:  # kein GPIO (z. B. beim Testen auf einem Laptop)
    print(f"GPIO unavailable, running without LED: {exc}")
    led = None

HOST = os.getenv("MQTT_HOST", "broker.connectmq.com")
PORT = int(os.getenv("MQTT_PORT", "1883"))
USE_TLS = os.getenv("MQTT_TLS", "0") == "1"
USERNAME = os.getenv("MQTT_USERNAME")
PASSWORD = os.getenv("MQTT_PASSWORD")
DEVICE_ID = os.getenv("DEVICE_ID", f"pi-{uuid.uuid4().hex[:6]}")
CLIENT_ID = os.getenv("MQTT_CLIENT_ID", DEVICE_ID)
PREFIX = os.getenv("TOPIC_PREFIX", f"connectmq/demo/{DEVICE_ID}")
INTERVAL = float(os.getenv("PUBLISH_INTERVAL", "10"))

T_TELEMETRY = f"{PREFIX}/telemetry"
T_LED_SET = f"{PREFIX}/led/set"
T_LED_STATE = f"{PREFIX}/led/state"
T_STATUS = f"{PREFIX}/status"

stop_event = threading.Event()


def read_cpu_temp() -> float:
    with open("/sys/class/thermal/thermal_zone0/temp") as f:
        return round(int(f.read().strip()) / 1000.0, 1)


def publish_led_state(client: mqtt.Client) -> None:
    state = "ON" if (led and led.is_lit) else "OFF"
    client.publish(T_LED_STATE, state, qos=1, retain=True)


def on_connect(client, userdata, flags, reason_code, properties):
    if reason_code.is_failure:
        print(f"Connect failed: {reason_code}")
        return
    print(f"Connected to {HOST}:{PORT} as {CLIENT_ID}")
    client.publish(T_STATUS, "online", qos=1, retain=True)
    client.subscribe(T_LED_SET, qos=1)
    publish_led_state(client)


def on_disconnect(client, userdata, disconnect_flags, reason_code, properties):
    print(f"Disconnected ({reason_code}), paho will retry automatically")


def on_message(client, userdata, msg):
    command = msg.payload.decode("utf-8", errors="ignore").strip().upper()
    print(f"Command on {msg.topic}: {command}")
    if led is None:
        return
    if command == "ON":
        led.on()
    elif command == "OFF":
        led.off()
    elif command == "TOGGLE":
        led.toggle()
    else:
        print("Unknown command, ignoring")
        return
    publish_led_state(client)


def build_client() -> mqtt.Client:
    client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id=CLIENT_ID)
    if USERNAME:
        client.username_pw_set(USERNAME, PASSWORD)
    if USE_TLS:
        client.tls_set(cert_reqs=ssl.CERT_REQUIRED)
    client.will_set(T_STATUS, "offline", qos=1, retain=True)
    client.reconnect_delay_set(min_delay=1, max_delay=60)
    client.on_connect = on_connect
    client.on_disconnect = on_disconnect
    client.on_message = on_message
    return client


def main() -> None:
    client = build_client()
    client.connect_async(HOST, PORT, keepalive=30)
    client.loop_start()

    signal.signal(signal.SIGTERM, lambda *_: stop_event.set())
    signal.signal(signal.SIGINT, lambda *_: stop_event.set())

    while not stop_event.is_set():
        if client.is_connected():
            payload = {
                "cpu_temp": read_cpu_temp(),
                "load": round(os.getloadavg()[0], 2),
                "ts": int(time.time()),
            }
            client.publish(T_TELEMETRY, json.dumps(payload), qos=0)
        stop_event.wait(INTERVAL)

    client.publish(T_STATUS, "offline", qos=1, retain=True).wait_for_publish(2)
    client.loop_stop()
    client.disconnect()


if __name__ == "__main__":
    main()

Starten Sie es mit einer festen Geräte-ID, damit Sie wissen, welche Topics Sie beobachten müssen:

cd ~/pi-mqtt && source .venv/bin/activate
DEVICE_ID=pi-7f3a python pi_mqtt.py

So funktioniert der Code

Einige Designentscheidungen lohnt es sich zu verstehen, denn genau hier gehen die meisten Pi-Projekte schief:

• connect_async plus loop_start führt die Netzwerkschleife in einem Hintergrund-Thread aus und lässt paho auch den ersten Verbindungsversuch wiederholen. Ein einfaches connect() wirft eine Exception und beendet das Skript, wenn das Netzwerk noch nicht bereit ist, was direkt nach dem Booten häufig vorkommt.
• Der Last Will (will_set) wird vom Broker beim Verbinden gespeichert. Verliert der Pi den Strom, veröffentlicht der Broker nach Ablauf des Keep-Alive für Sie offline. Der saubere Beendigungspfad veröffentlicht offline explizit.
• Retained-Zustands-Topics sorgen dafür, dass ein später verbundenes Dashboard den aktuellen LED-Zustand und den Online-Status sofort sieht, ohne auf die nächste Änderung zu warten.
• Abonnieren innerhalb von on_connect stellt das Abonnement nach jedem Reconnect wieder her. Einmal nach connect() zu abonnieren ist ein klassischer Fehler, der Befehle nach dem ersten Netzwerkaussetzer stillschweigend verstummen lässt.
• QoS 1 für Befehle und Zustände, QoS 0 für Telemetrie ist ein sinnvoller Standard. Einen periodischen Messwert zu verlieren ist harmlos; einen OFF-Befehl zu verlieren nicht. Unser Leitfaden zu MQTT QoS-Stufen erklärt die Abwägungen ausführlich.

Schritt 4: GPIO per MQTT steuern

Senden Sie bei laufendem Skript Befehle von Ihrem Laptop:

mosquitto_pub -h broker.connectmq.com -p 1883 -i cmd-laptop-7f3a -q 1 -t "connectmq/demo/pi-7f3a/led/set" -m "ON"
mosquitto_pub -h broker.connectmq.com -p 1883 -i cmd-laptop-7f3a -q 1 -t "connectmq/demo/pi-7f3a/led/set" -m "TOGGLE"

Die LED schaltet, und das Subscriber-Fenster zeigt den neuen Retained-Zustand auf led/state. Dasselbe Muster steuert ein Relais für eine Pumpe, einen Lüfter oder einen Türöffner; tauschen Sie einfach LED gegen gpiozero.OutputDevice und erwägen Sie, die Logik bei Low-aktiven Relaisplatinen zu invertieren. Für Taster, PWM-Dimmung und mehrere Pins machen Sie mit dem eigenen Leitfaden Raspberry Pi GPIO über MQTT weiter, und für Hardware, die Netzspannung schaltet, lesen Sie Raspberry-Pi-Relaissteuerung mit MQTT zur sicheren Verdrahtung.

Eine praktische Regel für Aktoren: Das Gerät, nicht das Dashboard, kennt die Wahrheit. Veröffentlichen Sie immer den Zustand, den die Hardware tatsächlich erreicht hat, und lassen Sie Benutzeroberflächen dieses Zustands-Topic anzeigen, statt anzunehmen, dass der Befehl funktioniert hat.

Schritt 5: Einen echten Sensor ergänzen

Die CPU-Temperatur beweist, dass die Pipeline funktioniert, aber die meisten Projekte messen den Raum. Ersetzen Sie read_cpu_temp() durch eine Sensorabfrage und fügen Sie die Werte dem Payload-Dictionary hinzu. Die folgende Tabelle fasst die gängigen Optionen zusammen und zeigt, wo es weitergeht:

Halten Sie Sensorabfragen aus den MQTT-Callbacks heraus. Callbacks laufen im Netzwerk-Thread, und eine langsame Sensorabfrage dort verzögert die Keep-Alive-Verarbeitung und Bestätigungen. Die Hauptschleife im obigen Skript ist der richtige Ort für alles, was blockiert.

Verwenden Sie über alle Geräte hinweg eine einheitliche JSON-Struktur: numerische Werte, SI-Einheiten im Schlüsselnamen oder in einem separaten Feld unit und einen Unix-Zeitstempel. Jeder Abnehmer, den Sie später ergänzen, von Grafana bis Node-RED, wird es Ihnen danken.

Schritt 6: Das MQTT-Skript mit systemd beim Booten starten

Ein aus einer SSH-Sitzung gestartetes Skript stirbt, wenn Sie sich abmelden. Machen Sie daraus einen systemd-Dienst, damit es beim Booten startet und bei Fehlern neu startet. Legen Sie /etc/systemd/system/pi-mqtt.service an:

[Unit]
Description=Raspberry Pi MQTT client
After=network-online.target
Wants=network-online.target

[Service]
User=pi
WorkingDirectory=/home/pi/pi-mqtt
EnvironmentFile=/home/pi/pi-mqtt/.env
ExecStart=/home/pi/pi-mqtt/.venv/bin/python /home/pi/pi-mqtt/pi_mqtt.py
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

Ersetzen Sie pi durch Ihren Benutzernamen, fügen Sie den Benutzer bei Bedarf der Gruppe gpio hinzu (sudo usermod -aG gpio pi) und legen Sie die Datei .env an:

cat > ~/pi-mqtt/.env <<'EOF'
DEVICE_ID=pi-7f3a
PUBLISH_INTERVAL=10
EOF
sudo systemctl daemon-reload
sudo systemctl enable --now pi-mqtt
journalctl -u pi-mqtt -f

Da das Skript SIGTERM behandelt, veröffentlicht systemctl stop pi-mqtt vor dem Beenden einen sauberen offline-Status. Zu Log-Rotation, Watchdogs und Alternativen wie cron @reboot siehe ein Python-MQTT-Skript beim Booten starten.

Schritt 7: Vom öffentlichen zum privaten Broker wechseln

Der öffentliche Broker ist ideal zum Lernen, aber er ist geteilt, anonym und ratenbegrenzt (zum Beispiel 10 Nachrichten pro Sekunde pro Client und 64 KB pro Nachricht). Für alles, worauf Sie sich verlassen, wollen Sie eigene Zugangsdaten, Verschlüsselung und Isolation. Sie haben zwei Optionen:

Den lokalen Betrieb von Mosquitto behandelt Mosquitto auf einem Raspberry Pi installieren. Wenn Sie sich für einen verwalteten MQTT-Broker entscheiden, erhalten Sie mit ConnectMQ in wenigen Minuten einen privaten Broker: Registrieren Sie sich, wählen Sie einen Plan, erstellen Sie einen Broker, und das Portal zeigt einen generierten Benutzernamen, ein Passwort und eine Client ID. Bearbeiten Sie dann nur die Datei .env:

cat > ~/pi-mqtt/.env <<'EOF'
MQTT_HOST=broker.connectmq.com
MQTT_PORT=8883
MQTT_TLS=1
MQTT_USERNAME=YOUR_USERNAME
MQTT_PASSWORD=YOUR_PASSWORD
MQTT_CLIENT_ID=YOUR_CLIENT_ID
DEVICE_ID=pi-7f3a
TOPIC_PREFIX=home/livingroom/pi-7f3a
EOF
sudo systemctl restart pi-mqtt

Port 8883 nutzt TLS mit einem öffentlich vertrauenswürdigen Let's-Encrypt-Zertifikat, daher validiert tls_set() es mit dem CA-Bundle, das mit Raspberry Pi OS ausgeliefert wird; Sie müssen keine Zertifikatsdateien auf den Pi kopieren. Bei ConnectMQ sind Client IDs an die ausgegebenen Zugangsdaten gebunden, verwenden Sie also die Client ID aus dem Portal statt einer zufälligen. Testen Sie von Ihrem Laptop mit denselben Zugangsdaten:

mosquitto_sub -h broker.connectmq.com -p 8883 --capath /etc/ssl/certs \
  -u YOUR_USERNAME -P YOUR_PASSWORD -i YOUR_CLIENT_ID-cli -v -t "home/#"

Wenn das Portal nur eine einzige Client ID ausgegeben hat, legen Sie für den Laptop einen zweiten Satz Zugangsdaten an, statt die des Pi wiederzuverwenden; zwei Verbindungen mit derselben ID werfen sich gegenseitig hinaus. Das Portal enthält außerdem einen MQTT-Client im Browser und einen Live-Topic-Explorer, oft der schnellste Weg, die Nachrichten Ihres Pi ohne Installation eintreffen zu sehen.

Checkliste zum Raspberry Pi MQTT Tutorial für zuverlässige Geräte

Die meisten „Gestern ging es noch“-Probleme stammen aus derselben kurzen Liste. Bevor Sie einen Pi im Schrank zurücklassen, gehen Sie sie durch:

1. Eindeutige Client ID pro Verbindung. Duplikate verursachen endlose Reconnect-Schleifen.
2. Abonnements innerhalb von on_connect. Sonst verstummen Befehle nach dem ersten Reconnect.
3. Last Will und Retained-Status. Dashboards müssen „still“ von „tot“ unterscheiden können.
4. TLS auf Port 8883 mit Zugangsdaten für alles außerhalb eines Labors. Siehe die vollständige Liste der MQTT Security Best Practices.
5. systemd mit Restart=on-failure und Logs in journald.
6. Messwerte offline puffern, wenn Lücken wichtig sind. Paho puffert QoS-1-Nachrichten während einer Trennung, aber nur im Speicher; MQTT-Nachrichten in Python offline puffern zeigt einen SQLite-basierten Ansatz, der Neustarts übersteht.
7. Ein gutes Netzteil und eine hochwertige SD-Karte, oder Booten von SSD. Unterspannung verursacht mehr zufällige Verbindungsabbrüche als jeder Softwarefehler.
8. Das Betriebssystem härten: nur SSH-Schlüssel, automatische Sicherheitsupdates, keine Standardpasswörter. Ein Raspberry-Pi-IoT-Gerät absichern führt Sie durch die Schritte.

Fehlerbehebung

Connect failed: Not authorized bedeutet, dass Benutzername, Passwort oder Client ID nicht mit den vom Broker ausgegebenen übereinstimmen. Kopieren Sie sie erneut aus dem Portal und prüfen Sie .env auf Leerzeichen am Zeilenende.

ConnectionRefusedError oder Timeouts auf 8883 bedeuten meist, dass eine Firewall oder ein Gästenetz ausgehende Ports blockiert. Testen Sie mit nc -vz broker.connectmq.com 8883. Manche Firmennetze erlauben nur 443; in diesem Fall ist eventuell auch MQTT über Secure WebSocket auf Port 8084 blockiert, testen Sie es also, bevor Sie sich festlegen.

ssl.SSLCertVerificationError bedeutet fast immer, dass die Uhr des Pi falsch geht. TLS braucht ein korrektes Datum; prüfen Sie timedatectl und stellen Sie sicher, dass NTP aktiviert ist.

Die LED reagiert nicht, aber Nachrichten kommen an: Das deutet auf GPIO-Berechtigungen oder die Verdrahtung hin. Führen Sie auf aktuellem Raspberry Pi OS pinctrl get 17 aus, um den Pin-Zustand zu sehen, und prüfen Sie, ob der Benutzer in der Gruppe gpio ist.

Reconnect-Schleife alle paar Sekunden: Das ist eine doppelte Client ID oder eine zweite noch laufende Kopie des Skripts. Prüfen Sie mit ps aux | grep pi_mqtt.

Wie es weitergeht

Dieses Raspberry Pi MQTT Tutorial gibt Ihnen eine solide Basis, und der Rest unserer Raspberry-Pi-Reihe baut genau auf diesem Skript auf:

• Machen Sie den Pi mit dem Leitfaden zum Raspberry-Pi-IoT-Gateway zum Protokollübersetzer, auch für Modbus- und BLE-Quellen, etwa um Maschinendaten in der Werkhalle zu erfassen und in einen Unified Namespace (UNS) mit ISA-95-Topic-Struktur einzuspeisen.
• Sie brauchen etwas Kleineres und Günstigeres für Batterieprojekte? Probieren Sie MQTT auf dem Raspberry Pi Pico W mit MicroPython.
• Speichern und visualisieren Sie Ihre Messwerte mit Grafana und InfluxDB auf einem Raspberry Pi.
• Veröffentlichen Sie Zustandsdaten für eine ganze Flotte mit Raspberry-Pi-Systemwerten über MQTT.

Starten Sie mit ConnectMQ

Wenn Ihr Pi-Projekt dem öffentlichen MQTT-Broker entwächst, erstellen Sie einen privaten Broker bei ConnectMQ. Der kostenlose Serverless-Plan benötigt keine Kreditkarte, unterstützt bis zu 25 Verbindungen und bietet TLS auf Port 8883, MQTT 5 und WebSocket-Zugang direkt ab Werk, mehr als genug für ein Heimlabor oder ein erstes Pilotprojekt. Größere Flotten können auf kostenpflichtige Serverless- oder Dedicated-Pläne wechseln, ohne eine Zeile Client-Code zu ändern. Erstellen Sie Ihren kostenlosen Broker unter app.connectmq.com und richten Sie Ihre .env-Datei darauf aus. Wenn Sie zuerst einen Überblick über die Hosting-Optionen möchten, lesen Sie unsere Übersicht zur Wahl eines Cloud-MQTT-Brokers.

Häufig gestellte Fragen

Welche MQTT-Bibliothek sollte ich auf einem Raspberry Pi verwenden?

Für Python ist paho-mqtt 2.x am weitesten verbreitet und wird auch in diesem Leitfaden verwendet. Node.js-Nutzer können MQTT.js einsetzen, und Low-Code-Nutzer können Node-RED mit denselben Broker-Einstellungen auf dem Pi betreiben.

Kann ein Raspberry Pi gleichzeitig MQTT-Broker und Client sein?

Ja. Sie können Mosquitto auf dem Pi betreiben und lokale Skripte mit localhost verbinden, müssen sich dann aber selbst um Sicherheit, Updates und Fernzugriff kümmern. Viele Projekte belassen den Pi als Client und nutzen einen verwalteten MQTT-Broker, damit sich Geräte und Dashboards an verschiedenen Orten erreichen.

Warum trennt sich mein Pi ständig und verbindet sich neu?

Die häufigsten Ursachen sind eine doppelte Client ID, eine zweite laufende Kopie des Skripts oder ein instabiles Netzteil. Prüfen Sie, ob jede Verbindung eine eindeutige ID nutzt, und suchen Sie mit dmesg nach Unterspannungswarnungen.

Ist der öffentliche Broker für mein Raspberry-Pi-Projekt sicher?

Für Lernzwecke und Demos ja, aber jeder Client kann öffentliche Topics lesen, senden Sie also niemals personenbezogene oder sensible Daten. Verwenden Sie für echte Einsätze einen privaten Broker mit TLS und Zugangsdaten.

Funktioniert dieser Code auf dem Raspberry Pi 5?

Ja. Das Skript nutzt gpiozero mit dem lgpio-Backend, das den Pi 5 unterstützt. Bibliotheken, die in die alten GPIO-Speicherregister schreiben, wie RPi.GPIO, funktionieren auf dem Pi 5 nicht.