Raspberry Pi für Heimautomation einrichten und verwenden: Hardware, Software und Beispiele

Ein Raspberry Pi ist ein leistungsfähiges, flexibles Zentrum für die Heimautomation. In diesem Tutorial planst du die Hardware, installierst und sicherst das Betriebssystem, setzt Kernservices wie MQTT, Node-RED und Home Assistant auf und baust dann zwei praktische Automatisierungen: das Veröffentlichen von Temperaturdaten von einem GPIO-Sensor und das Steuern einer Lampe über Zigbee. Am Ende hast du eine zuverlässige Grundlage, die du Raum für Raum erweitern kannst.

Hardwareplanung

Wähle Komponenten, die zur Größe deines Hauses, zu den benötigten Protokollen und zu deinen Zuverlässigkeitserwartungen passen.

• Raspberry Pi: Ein Pi 4 (4–8 GB RAM) oder Pi 5 (8 GB) ist ideal. Ein Pi 3B+ kann für leichte Lasten funktionieren. Wenn du Home Assistant plus mehrere Container betreibst, gilt: lieber 4+ GB.
• Speicher: Bevorzuge eine SSD (USB-3-Gehäuse) für Zuverlässigkeit und Geschwindigkeit. MicroSD funktioniert für kleine Setups; verwende eine hochwertige A2-Karte (32–128 GB).
• Stromversorgung: Nutze das offizielle oder ein hochwertiges Netzteil (Pi 4: 5V 3A USB-C; Pi 5: 5V 5A USB-C PD). Unterspannung verursacht Instabilität.
• Netzwerk: Kabelgebundenes Ethernet ist am besten. Wenn du Wi‑Fi nutzt, sorge für gute 2,4‑GHz-Abdeckung für IoT-Geräte.
• Protokoll-Dongles:
  • Zigbee: Sonoff Zigbee 3.0 USB, ConBee II oder Electrolama zzh.
  • Z‑Wave: Aeotec Z‑Stick 7.
  • Halte Zigbee-/Z‑Wave‑Sticks an einem kurzen USB‑2.0‑Verlängerungskabel, um Störungen durch USB‑3 zu reduzieren.
• Sensoren/Aktoren: GPIO-freundliche Geräte (DS18B20 Temperatursensor, Relais/HATs) oder IP‑Geräte (Smart Plugs, Lampen, ESPHome, Tasmota).
• Gehäuse und Kühlung: Ein Gehäuse mit Kühlkörpern/Lüfter wird empfohlen, besonders bei Dauerlast.
• Optional: UPS‑HAT oder kleine DC‑USV, um SD/Dateisystem‑Korruption bei Stromausfällen zu vermeiden.

Raspberry Pi OS installieren und härten

Du kannst auf dem Pi dediziertes Home Assistant OS laufen lassen, aber für ein universelles Hub (MQTT, Node‑RED, HA‑Container) ist Raspberry Pi OS Lite (64‑bit) eine hervorragende Basis.

Raspberry Pi OS flashen

1. Lade den Raspberry Pi Imager auf deinen PC herunter und installiere ihn.
2. Wähle Raspberry Pi OS Lite (64‑bit). Klicke auf das Zahnrad‑Icon (erweiterte Optionen):
   • Setze Hostname (z. B. rpi-home).
   • Erstelle einen Non‑Root‑Benutzer mit starkem Passwort oder SSH‑Key.
   • Aktiviere SSH.
   • Konfiguriere Wi‑Fi bei Bedarf (Land, SSID, Passwort).
   • Setze Locale/Zeitzone.
3. Auf SSD oder MicroSD flashen und den Pi booten.

Aufgaben beim ersten Start

SSH zum Pi (oder benutze Tastatur/Monitor):

• Aktualisieren und neu starten:

sudo apt update && sudo apt full-upgrade -y
sudo reboot

• Eine statische IP setzen (empfohlen) mit NetworkManager:

nmcli con show
# Identifiziere deine Verbindung, z. B. "Wired connection 1" oder "WLAN"
sudo nmcli con mod "Wired connection 1" ipv4.method manual ipv4.addresses 192.168.1.50/24 ipv4.gateway 192.168.1.1 ipv4.dns "1.1.1.1 8.8.8.8"
sudo nmcli con up "Wired connection 1"

• SSH härten (Schlüssel bevorzugt). Wenn du Schlüssel mit dem Imager gesetzt hast, deaktiviere Passwort-Login:

sudo install -m 0644 /dev/stdin /etc/ssh/sshd_config.d/10-security.conf << 'EOF'
PasswordAuthentication no
ChallengeResponseAuthentication no
PubkeyAuthentication yes
EOF
sudo systemctl reload ssh

• Optional: Firewall:

sudo apt install -y ufw
sudo ufw allow 22/tcp
sudo ufw allow 1883/tcp   # MQTT
sudo ufw allow 8123/tcp   # Home Assistant
sudo ufw enable

• 1‑Wire‑Overlays (für GPIO‑Sensoren) bei Bedarf später erweitern.

Kernservices für die Automation

Wir installieren einen MQTT‑Broker (Mosquitto), Node‑RED für Flows und Home Assistant Container für UI und Integrationen.

MQTT‑Broker (Mosquitto)

1. Installation:

sudo apt install -y mosquitto mosquitto-clients

1. Einen Benutzer anlegen und die Konfiguration sichern:

sudo mosquitto_passwd -c /etc/mosquitto/passwd homeauto
# Enter a strong password
sudo install -m 0644 /dev/stdin /etc/mosquitto/conf.d/local.conf << 'EOF'
allow_anonymous false
password_file /etc/mosquitto/passwd
listener 1883 0.0.0.0
EOF
sudo systemctl restart mosquitto

1. Test:

mosquitto_sub -h localhost -u homeauto -P 'YOURPASS' -t 'test/#' -v &
mosquitto_pub -h localhost -u homeauto -P 'YOURPASS' -t 'test/hello' -m 'world'

Node‑RED

Installiere das kuratierte Node‑RED‑ + Node.js‑LTS‑Skript und aktiviere den Service.

bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered)
sudo systemctl enable nodered --now

Zugriff auf Node‑RED unter http://<pi-ip>:1880. Füge Knoten für MQTT, Home Assistant etc. über den Palette Manager hinzu.

Home Assistant (Container)

Wenn du die volle Supervisor‑Experience möchtest, flash Home Assistant OS stattdessen. Andernfalls den Container auf Raspberry Pi OS ausführen:

1. Docker installieren:

curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
newgrp docker

1. Home Assistant starten:

mkdir -p ~/homeassistant
docker run -d --name homeassistant --restart unless-stopped --privileged --network host \
  -v /etc/localtime:/etc/localtime:ro \
  -v ~/homeassistant:/config \
  ghcr.io/home-assistant/home-assistant:stable

Öffne http://<pi-ip>:8123, um das Onboarding abzuschließen.

Beispiel 1: GPIO‑Temperatursensor zu MQTT

Wir verbinden einen DS18B20 1‑Wire Temperatursensor an GPIO4, lesen ihn mit Python aus und publizieren die Werte per MQTT. Verkabelung (typisch):

• DS18B20 GND → Pi GND
• DS18B20 VDD → Pi 3.3V
• DS18B20 DATA → GPIO4 (Pin 7), mit einem 4,7 kΩ Pull‑Up‑Widerstand zu 3.3V

1‑Wire aktivieren

Auf Raspberry Pi OS (Bookworm) /boot/firmware/config.txt bearbeiten:

sudo sed -i '$a dtoverlay=w1-gpio' /boot/firmware/config.txt
sudo reboot

Sensor lesen und veröffentlichen

Python‑Abhängigkeiten installieren und ein Skript erstellen:

sudo apt install -y python3-venv
python3 -m venv ~/envs/homeauto && source ~/envs/homeauto/bin/activate
pip install paho-mqtt

Erstelle read_temp.py:

#!/usr/bin/env python3
import glob, time
import paho.mqtt.client as mqtt

MQTT_HOST = "localhost"
MQTT_USER = "homeauto"
MQTT_PASS = "YOURPASS"
TOPIC = "home/livingroom/temperature"

def read_ds18b20_c():
    base = "/sys/bus/w1/devices/"
    device_folders = glob.glob(base + "28-*")
    if not device_folders:
        raise RuntimeError("No DS18B20 detected")
    device_file = device_folders[0] + "/w1_slave"
    with open(device_file, "r") as f:
        lines = f.readlines()
    if "YES" not in lines[0]:
        raise RuntimeError("CRC error")
    temp_str = lines[1].split("t=")[-1].strip()
    return float(temp_str) / 1000.0

def main():
    temp_c = read_ds18b20_c()
    client = mqtt.Client()
    client.username_pw_set(MQTT_USER, MQTT_PASS)
    client.connect(MQTT_HOST, 1883, 60)
    payload = {"temperature": round(temp_c, 2), "unit": "C"}
    client.publish(TOPIC, str(payload), qos=1, retain=True)
    client.disconnect()

if __name__ == "__main__":
    main()

Mach es ausführbar und teste:

chmod +x ~/read_temp.py
~/envs/homeauto/bin/python ~/read_temp.py
mosquitto_sub -h localhost -u homeauto -P 'YOURPASS' -t 'home/livingroom/temperature' -v

Periodisch ausführen

Verwende einen systemd‑Timer für Zuverlässigkeit:

sudo tee /etc/systemd/system/temp-publisher.service >/dev/null <<'EOF'
[Unit]
Description=Publish DS18B20 temperature to MQTT

[Service]
Type=oneshot
User=pi
Environment=PATH=/home/pi/envs/homeauto/bin:/usr/bin
ExecStart=/home/pi/envs/homeauto/bin/python /home/pi/read_temp.py
EOF

sudo tee /etc/systemd/system/temp-publisher.timer >/dev/null <<'EOF'
[Unit]
Description=Run temperature publisher every minute

[Timer]
OnBootSec=30
OnUnitActiveSec=60

[Install]
WantedBy=timers.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now temp-publisher.timer

In Home Assistant füge einen MQTT‑Sensor hinzu (Einstellungen → Geräte & Dienste → MQTT → Konfigurieren), oder ziehe in Node‑RED einfach ein MQTT‑in‑Node für das Topic home/livingroom/temperature und verbinde es mit einem Debug‑ oder Dashboard‑Node.

Beispiel 2: Bewegungssteuerung einer Zigbee‑Lampe mit Home Assistant

Dieses Beispiel verwendet einen Zigbee‑USB‑Koordinator, Home Assistant’s ZHA‑Integration, einen Bewegungsmelder und eine smarte Glühbirne oder Schalter. ZHA vermeidet zusätzliche Container; wenn du Zigbee2MQTT bevorzugst, kannst du die Schritte entsprechend anpassen.

Hardware vorbereiten

• Stecke deinen Zigbee‑USB‑Stick in den Pi über ein kurzes USB‑2.0‑Verlängerungskabel (reduziert Interferenzen).
• Finde den stabilen Gerätepfad:

ls -l /dev/serial/by-id/
# Notiere den vollständigen by-id-Pfad, z. B. /dev/serial/by-id/usb-ITead_Sonoff_Zigbee_3.0_Coordinator_*

ZHA in Home Assistant hinzufügen

1. Öffne Einstellungen → Geräte & Dienste → Integration hinzufügen → „Zigbee Home Automation (ZHA)“.
2. Wähle das serielle Gerät über den by-id‑Pfad. Wähle EZSP oder ZNP je nach Stick; die Defaults sind meist korrekt.
3. Geräte anlernen:
   • Versetze den Bewegungsmelder und die Lampe in den Pairing‑Modus (siehe Handbücher).
   • In ZHA auf Gerät hinzufügen klicken und auf Entdeckung warten.
4. Benenne die Entitäten sinnvoll um, z. B. binary_sensor.hall_motion, light.hall_ceiling.

Die Automation erstellen

In Home Assistant: Einstellungen → Automationen → Automation erstellen → Von Grund auf neu.

• Auslöser: Gerät → Hall Motion → „Bewegung erkannt“.
• Bedingung: Optionaler Zeitbereich (z. B. nach Sonnenuntergang).
• Aktion: Gerät → Hall Ceiling Light → Einschalten. Füge eine Verzögerung hinzu und „Ausschalten“, wenn keine Bewegung mehr für N Minuten erkannt wird, z. B. mit „Wait for trigger“ oder einem separaten „state“-Trigger auf „cleared“.

Ein YAML‑Beispiel:

alias: Hall light on motion
mode: restart
trigger:
  - platform: state
    entity_id: binary_sensor.hall_motion
    from: "off"
    to: "on"
condition:
  - condition: sun
    after: sunset
action:
  - service: light.turn_on
    target: { entity_id: light.hall_ceiling }
  - wait_for_trigger:
      - platform: state
        entity_id: binary_sensor.hall_motion
        to: "off"
        for: "00:05:00"
  - service: light.turn_off
    target: { entity_id: light.hall_ceiling }

Das war’s — deine Flur‑Lampe schaltet sich bei erkannter Bewegung nach Sonnenuntergang ein und nach 5 Minuten ohne Bewegung wieder aus.

Optional: Zigbee2MQTT + Node‑RED‑Alternative

Wenn du Automationen lieber in Node‑RED behalten und MQTT überall verwenden möchtest:

1. Zigbee2MQTT betreiben:

mkdir -p ~/zigbee2mqtt/data
docker run -d --name zigbee2mqtt --restart unless-stopped --network host \
  --device /dev/serial/by-id/usb-YOUR_ZIGBEE_STICK_ID \
  -v ~/zigbee2mqtt/data:/app/data -v /run/udev:/run/udev:ro \
  koenkk/zigbee2mqtt

1. Öffne http://<pi-ip>:8080 (falls Frontend aktiviert), um Geräte zu paaren.
2. In Node‑RED Topics wie zigbee2mqtt/motion_sensor und zigbee2mqtt/light/set konsumieren und Flows bauen wie:

• MQTT‑in (motion) → RBE (wiederholungsfilter) → Switch (nur „occupied“) → MQTT‑out (light set {"state":"ON"}). So bleibt die Logik visuell und versionierbar (Flows als JSON exportieren).

Fernzugriff und Dashboards

• Home Assistant: Zugriff über App oder Browser. Für sicheren Fernzugriff bevorzuge Tailscale oder WireGuard statt Router‑Port‑Forwarding. Tailscale auf dem Pi installieren:

curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up

• Node‑RED Dashboard: Installiere node-red-dashboard über den Palette Manager. Stelle es nur über VPN bereit oder setze Nginx mit TLS davor, falls Internetzugriff nötig ist.

Wartung und Überwachung

• Backups:
  • Home Assistant Container: Nutze das Backup‑Integrations-Add‑on oder sichere periodisch das ~/homeassistant Verzeichnis per tar.
  • Node‑RED: Exportiere Flows und sichere ~/.node-red.
  • Ziehe Dateisystem‑Snapshots (btrfs) oder Tools wie restic für Offsite‑Backups in Betracht.
• Updates:

sudo apt update && sudo apt upgrade -y
docker pull ghcr.io/home-assistant/home-assistant:stable && docker restart homeassistant
docker pull koenkk/zigbee2mqtt && docker restart zigbee2mqtt

• Health:
  • Überwache mit Glances oder Home Assistant system monitor.
  • Halte CPU‑Temperaturen <70°C; füge bei Bedarf einen Lüfter hinzu.
• Lebensdauer des Speichers:
  • Bevorzuge SSD. Wenn MicroSD genutzt wird, minimiere Schreibzugriffe: deaktiviere unnötige Logs, verschiebe Datenbanken (z. B. Recorder in HA) auf eine SSD oder eine externe DB.
• Stromstabilität:
  • Vermeide Brownouts mit einem guten Netzteil und, wenn möglich, einer kleinen USV. Nutze ein sicheres Herunterfahr‑Skript bei niedrigem Akku mit UPS‑HATs.

Best Practices und häufige Fallstricke

• Verwende Ethernet für den Pi; Wi‑Fi ist für Endgeräte okay, aber weniger ideal für das Hub.
• Platziere Zigbee/Z‑Wave‑Sticks auf einem USB‑2.0‑Verlängerungskabel und weg vom Pi, um Störungen durch 2,4‑GHz‑Geräusche von USB‑3‑Anschlüssen zu vermeiden.
• Nutze Gerätepfade by‑id (z. B. /dev/serial/by-id/...), damit Reboots Integrationen nicht zerschießen.
• Sichere MQTT: starke Zugangsdaten, für jeden Dienst eigene User und erwäge, den Listener nur im LAN oder nur über Tailscale zu binden.
• Überkompliziere nicht am Anfang: starte mit einem Protokoll (Zigbee oder Wi‑Fi) und ein paar Automationen; dokumentiere Namenskonventionen, während du wächst.
• Halte Automationen idempotent und robust: behandle offline‑Zustände, setze Timeouts und teste bei Tag- und Nachtbedingungen.
• Vermeide breit gefasste Firewall‑Regeln; öffne nur Ports, die du wirklich nutzt (1883, 8123, 1880).
• Plane Entity‑Namen: room_device_function (z. B. kitchen_plug_kettle), um Dashboards und YAML lesbar zu halten.

Nächste Schritte

• Sensoren erweitern: CO2, Luftfeuchte, Energiemessung (ESPHome + CT‑Klemmen).
• Anwesenheitserkennung: Bluetooth‑Proxies, Handy‑Apps oder Router‑Präsenz für kontextbezogene Automationen.
• Energieoptimierung: Steuerung von HVAC‑Setpoints basierend auf Belegung und Tarifen; nutze das Energy‑Dashboard von Home Assistant.
• Versionsverwaltung: Lege Node‑RED‑Flows und HA‑YAML in Git ab für Rollbacks und Zusammenarbeit.

Mit einer soliden Raspberry Pi‑Basis, sicherem Netzwerk und dem Trio aus MQTT, Node‑RED und Home Assistant kannst du dich von einem einzelnen Raum zu einem ganzen Haus hocharbeiten — zuverlässig, transparent und nach deinen Regeln.