Eigenen KI-gestützten Smart-Home-Dashboard mit Raspberry Pi bauen

Schritt 1: Raspberry Pi 5 einrichten

Beginne mit der Installation von Raspberry Pi OS Lite (64-bit) auf deiner microSD-Karte:

1. Lade Raspberry Pi Imager herunter und installiere es
2. Wähle "Raspberry Pi OS (64-bit)" → "Lite" (keine Desktop-Umgebung, spart Ressourcen)
3. Drücke Ctrl+Shift+X für Advanced Options:
• Hostname: smartdashboard
• Benutzer: pi, Passwort: dein-sicheres-passwort
• WiFi konfigurieren (SSID und Passwort)
• SSH aktivieren
4. Schreibe das Image auf die microSD-Karte
5. Setze den Pi zusammen und starte ihn

Schritt 2: System aktualisieren und Grundprogramme installieren

Verbinde dich per SSH mit dem Raspberry Pi und führe folgende Befehle aus:

sudo apt update && sudo apt full-upgrade -y
sudo apt install -y python3 python3-pip python3-venv git curl wget
sudo apt install -y nginx python3-systemd

Schritt 3: Dashboard-Software installieren

Wir verwenden Glass (früher MirrorBrain), eine Open-Source-Smart-Home-Dashboard-Software:

# Virtual Environment erstellen
cd ~
python3 -m venv dashboard-venv
source dashboard-venv/bin/activate

# Glass installieren
pip install glass-dashboard

# Konfiguration erstellen
glass init /home/pi/glass-config

Alternativ kannst du auch Home Assistant mit der Mushroom Card-Integration verwenden:

# Home Assistant in Docker installieren
sudo apt install -y docker.io docker-compose
sudo usermod -aG docker pi

# docker-compose.yml erstellen
cat > ~/home-assistant/docker-compose.yml << 'EOF'
version: '3'
services:
  homeassistant:
    container_name: homeassistant
    image: "ghcr.io/home-assistant/home-assistant:stable"
    volumes:
      - /home/pi/homeassistant-config:/config
      - /etc/localtime:/etc/localtime:ro
      - /run/dbus:/run/dbus:ro
    restart: unless-stopped
    network_mode: host
EOF

# Home Assistant starten
cd ~/home-assistant
docker compose up -d

Schritt 4: Touchscreen konfigurieren

Der 10-Zoll-Touchscreen wird automatisch von Raspberry Pi OS erkannt. Für die optimale Konfiguration:

# Touchscreen kalibrieren und drehen (falls nötig)
sudo nano /boot/firmware/config.txt

# Füge hinzu:
# display_rotate=1 (für Hochformat)
# hdmi_group=2
# hdmi_mode=87
# hdmi_cvt=1024 600 60 6 0 0 0

# Touchscreen kalibrieren
sudo apt install -y xinput-calibrator
xinput_calibrator

Schritt 5: KI-Sprachsteuerung einrichten

Für die lokale Sprachsteuerung verwenden wir Whisper.cpp (OpenAI's Whisper in C++) und PocketSphinx für Befehlssteuerung:

# Whisper.cpp kompilieren
git clone https://github.com/ggerganov/whisper.cpp.git
cd whisper.cpp
make -j4

# Modell herunterladen
./models/download-ggml-model.sh base

# Test
./whisper -m models/ggml-base.bin -f samples/jfk.wav

Für Smart-Home-Befehle erstellen wir ein einfaches Python-Skript:

#!/usr/bin/env python3
import speech_recognition as sr
import requests
import json

def listen_command():
    recognizer = sr.Recognizer()
    with sr.Microphone() as source:
        print("Höre...")
        audio = recognizer.listen(source)
    try:
        text = recognizer.recognize_whisper(audio, model="base")
        print(f"Befehl: {text}")
        return text
    except:
        return None

def execute_command(command):
    if "licht an" in command:
        requests.post("http://localhost:8123/api/light/on")
        return "Licht an"
    elif "licht aus" in command:
        requests.post("http://localhost:8123/api/light/off")
        return "Licht aus"
    elif "wetter" in command:
        response = requests.get("https://api.open-meteo.com/v1/forecast")
        return f"Wetter: {response.json()}"
    return "Befehl nicht erkannt"

if __name__ == "__main__":
    while True:
        cmd = listen_command()
        if cmd:
            result = execute_command(cmd)
            print(result)

Schritt 6: Dashboard-Layout anpassen

Das Dashboard zeigt folgende Widgets:

• Energieverbrauch in Echtzeit (mit Shelly oder Tasmota-Sensoren)
• Wettervorhersage für die nächsten 7 Tage
• Kalender mit Google Calendar Integration
• Sicherheitskameras (RTSP-Stream von IP-Kameras)
• Smart-Home-Steuerung für Licht, Heizung, Rollläden
• Timer & Wecker
• Notizen und To-Do-Listen

Schritt 7: Automatischen Start konfigurieren

Das Dashboard soll automatisch beim Hochfahren starten:

sudo nano /etc/systemd/system/glass-dashboard.service

# Inhalt:
[Unit]
Description=Glass Smart Home Dashboard
After=network.target

[Service]
Type=simple
User=pi
WorkingDirectory=/home/pi
ExecStart=/home/pi/dashboard-venv/bin/python -m glass_dashboard
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

# Aktivieren
sudo systemctl enable glass-dashboard.service
sudo systemctl start glass-dashboard.service