Raspberry Projekt: Der schlaue Haustür-Wächter (KI ohne Cloud)

Wäre es nicht toll …?

… wenn lokale Objekterkennung smarte Abläufe steuert?

Stell dir vor:

Der Katzen-Türsteher: Deine Kamera erkennt im Garten deine Katze – und nur für sie entriegelt sich automatisch die Katzenklappe, während der Waschbär draußen bleiben muss.
Der Post-Melder: Sobald der Postbote vor dem Briefkasten steht, erhältst du eine kurze Nachricht auf dein Handy, damit du weißt, dass die wichtige Lieferung da ist.
Der Hof-Wächter: Dein Garagentor geht abends automatisch zu, wenn die KI erkennt, dass zwar dein Auto in der Einfahrt steht, du aber vergessen hast, das Tor zu schließen.

Wir bauen heute solch einen Wächter, der solche Aufgaben und weitere, ganz alleine schafft – ohne dass deine Daten dein Haus verlassen!

In meinem NPU-Beitrag haben wir das Raspberry Pi AI Kit eingebaut und die Hardware startklar gemacht. Heute gehen wir den nächsten Schritt: Wir programmieren uns einen eigenen KI-Wächter.

Was wir brauchen (Die Hardware)

Raspberry Pi (Modell 5 ab 4GB RAM)
Kühler für RPi5
Netzteil 5V 5A USB-C
Raspberry Pi Kamera-Modul 3
Hailo-8L NPU aus dem Raspberry Pi AI Kit
NVMe M.2 Shield X1002 für RPi 5
SD-Karte für RPi OS Debian Trixie Betriebssystem (64bit).
LEDs, Relays 3,3v, Kabel, Breadborad…

Alternative wenn die neue Hailo NPU die ja direkt mit dem Shield verlöteten ist, zum Einsatz kommen soll dann mit diesen GPIO Verlängerungsadapter.

Vorbereitung

Bevor wir unseren KI-Wächter programmieren, muss dein Raspberry Pi ’schlau‘ gemacht werden. Wie du das AI Kit mit der Hailo-NPU installierst, habe ich dir hier in diesem Beitrag Schritt für Schritt auch im Youtube Video gezeigt.

1. SD‑Karte neu flashen (Raspberry Pi OS 64‑bit)

Für das AI‑Kit wird Raspberry Pi OS ab Version Bookworm 64‑bit empfohlen.

Raspberry Pi Imager starten
Gerät: Raspberry Pi 5
OS: Raspberry Pi OS (64‑bit) Bei mir nun Trixie
Optional: WLAN, Hostname, SSH konfigurieren
Flashen → SD‑Karte einlegen → Booten

Nach dem ersten Start System updaten:

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

2. Firmware & Bootloader aktualisieren

Damit PCIe und Kamera sauber laufen:

sudo rpi-eeprom-update -a
sudo reboot

3. PCIe Gen3 für das AI‑Kit über `raspi-config` aktivieren

Das M.2‑HAT+ nutzt PCIe, und Hailo profitiert massiv von Gen3.
Unter Trixie findest du die Option hier:

sudo raspi-config → Advanced Options → PCIe Speed → Gen 3`
Speichern → Neustart

4. Hailo‑Software installieren

Die offiziellen Pakete kommen direkt aus den Raspberry‑Pi‑Repos.

sudo apt update
sudo apt install dkms
sudo apt install hailo-all
sudo reboot

Dieses Metapaket installiert:

Firmware
Kernel‑Treiber (DKMS)
HailoRT
Tools (hailortcli)

5. Funktionstest der NPU

Nach dem Reboot:

hailortcli device-info

Erwartete Ausgabe: Hailo‑8L, PCIe, FW‑Version …

6. Kamera testen

Camera Module 3:

rpicam-hello

Wenn ein Live‑Bild erscheint, ist der komplette libcamera‑Stack korrekt.

7. Optional: Hailo Apps Infrastructure integrieren

git clone https://github.com/hailo-ai/hailo-apps-infra.git
cd hailo-apps-infra
sudo ./scripts/cleanup_installation.sh
sudo ./install.sh

8. Prüfen, ob die NPU korrekt initialisiert wurde

Bevor du Pipelines testest, muss die NPU sauber laufen.

hailortcli fw-control identify

Wenn du eine Ausgabe wie „Hailo‑8L / Firmware Version …“ siehst, ist der Treiber aktiv und die Firmware geladen.

9. Kamera‑Stack testen (Pflicht vor jeder Pipeline)

Die rpicam‑Apps sind die Basis für alle Vision‑Pipelines. Nochmal testen

rpicam-hello

Wenn ein Live‑Bild erscheint, ist der komplette libcamera‑Stack korrekt eingerichtet

10: Das „KI-Gehirn“ installieren

Wir benutzen eine Software namens TensorFlow Lite. Das ist eine Version von Googles KI, die extra klein und schnell ist, damit sie auf dem Raspberry Pi läuft.

Tippe diesen Befehl ein, um die Erkennungs-Software zu laden:

sudo apt install python3-tflite-runtime

python3‑tflite‑runtime ist die kleine, schnelle KI‑Engine, die in unserem Projekt das YOLOv8‑Modell lädt und ausführt. Die Hailo‑NPU beschleunigt diese Berechnungen erheblich – aber ohne TFLite könnte der Raspberry Pi das Modell überhaupt nicht interpretieren oder nutzen.

Hintergrundwissen: Wie die KI in diesem Projekt eigentlich arbeitet

Bevor wir im nächsten Schritt den Python‑Code starten, lohnt sich ein kurzer Blick darauf, wie die KI im Hintergrund denkt. Das ist kein Pflichtwissen, aber es hilft zu verstehen, warum der Wächter so zuverlässig funktioniert.

Wie ein KI‑Modell lernt

Ein KI‑Modell lernt ähnlich wie ein Kind: Sieht ein Kind viele Bilder von Katzen, erkennt es irgendwann typische Merkmale wie Ohren, Fellmuster oder Schnurrhaare.
Genauso lernt ein Modell, indem es sehr viele Beispielbilder sieht und daraus Muster ableitet.

Eigene Modelle mit Teachable Machine

Mit Tools wie Teachable Machine kann man solche Modelle selbst trainieren – zum Beispiel, um zwischen deiner eigenen Katze und fremden Katzen zu unterscheiden. Man fotografiert das Objekt aus verschiedenen Blickwinkeln, und daraus entsteht ein kleines „Gehirn“, das später Bilder klassifiziert.

Warum hier YOLOv8 genutzt wird

Für den Haustür‑Wächter verwenden wir ein bereits fertig trainiertes Modell: YOLOv8, das auf der Hailo‑NPU läuft. Dieses Modell erkennt viele Objekte sofort – Menschen, Tiere, Pakete, Fahrzeuge und vieles mehr.
Die Kamera liefert das Bild, YOLOv8 analysiert es, und der Raspberry Pi entscheidet anschließend, was passieren soll.

Kombination: YOLO für Erkennung + Teachable Machine für Feinklassifikation

Man kann beide Ansätze auch kombinieren:

YOLOv8 (Hailo) erkennt zuerst das Objekt, z. B. „Katze“.
Ein selbst trainiertes Teachable‑Machine‑Modell kann dann den erkannten Bildausschnitt genauer einordnen – etwa ob es deine Katze ist oder ein fremdes Tier.

So bleibt die Erkennung schnell (dank Hailo‑NPU), während du trotzdem sehr individuelle Regeln umsetzen kannst.

11: Der Code (Der Türwächter-Plan)

Wir schreiben ein kleines Programm in der Sprache Python. Das Programm macht folgendes:

Die Kamera liefert ein Bild.
Das Bild wird an das KI‑Modell Yolov8 übergeben.
python3‑tflite‑runtime führt das Modell aus – entweder komplett auf der CPU oder (in deinem Fall) teilweise über die Hailo‑NPU.
Das Modell gibt Erkennungen zurück (z. B. „person“, „cat“, „cup“).
Dein Python‑Code reagiert darauf (LED an, Relais schalten usw.).

Wichtig für den Datenschutz: Das Programm speichert das Bild nicht im Internet. Es schaut es sich kurz an, entscheidet und „vergisst“ es dann wieder. Das nennt man Edge Computing (Rechnen am Rand des Netzwerks).

Python-Code:

import subprocess
import RPi.GPIO as GPIO
import time
import os
import select

# --- KONFIGURATION ---
PIN_MENSCH = 23  # Rote LED
PIN_GLAS = 24   # Grüne LED
MODEL_JSON = '/usr/share/rpi-camera-assets/hailo_yolov8_inference.json'

# Wie lange soll die LED nachleuchten (in Sekunden)?
HALTEZEIT = 2.0 

# --- HARDWARE SETUP ---
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(PIN_MENSCH, GPIO.OUT)
GPIO.setup(PIN_GLAS, GPIO.OUT)

GPIO.output(PIN_MENSCH, GPIO.LOW)
GPIO.output(PIN_GLAS, GPIO.LOW)

# Variablen für die Zeitsteuerung
letzter_mensch = 0
letztes_glas = 0

print("--- KI WÄCHTER GESTARTET ---")

# --- KI PROZESS STARTEN ---
cmd = [
    'rpicam-hello',
    '-t', '0',
    '--post-process-file', MODEL_JSON,
    '--viewfinder-width', '640',
    '--viewfinder-height', '640',
    '--verbose', '2',
    '--output', '-'
]

process = subprocess.Popen(
    cmd, 
    stdout=subprocess.PIPE, 
    stderr=subprocess.STDOUT, 
    text=True,
    bufsize=1
)

print("Suche aktiv... Die LEDs schalten automatisch ab, wenn nichts gesuchtes im Bild ist.")

try:
    while True:
        # Schau nach, ob neue Daten von der KI da sind (Wartezeit 0.1 Sek)
        r, _, _ = select.select([process.stdout], [], [], 0.1)
        
        if r:
            line = process.stdout.readline()
            if not line:
                break
            
            line_clean = line.lower().strip()
            
            if "person" in line_clean:
                print("Ein Person erkannt!")
                letzter_mensch = time.time()
                GPIO.output(PIN_MENSCH, GPIO.HIGH)
            
            elif "cup" in line_clean:
                print("Glas wurde erkannt!")
                letztes_glas = time.time()
                GPIO.output(PIN_GLAS, GPIO.HIGH)

        # --- ABSCHALT-LOGIK ---
        aktuelle_zeit = time.time()
        
        # Wenn die letzte Erkennung länger her ist als die HALTEZEIT, LED aus
        if aktuelle_zeit - letzter_mensch > HALTEZEIT:
            GPIO.output(PIN_MENSCH, GPIO.LOW)
            
        if aktuelle_zeit - letztes_glas > HALTEZEIT:
            GPIO.output(PIN_GLAS, GPIO.LOW)

except KeyboardInterrupt:
    print("\nAbbruch durch Nutzer.")

finally:
    process.terminate()
    GPIO.cleanup()
    print("Beendet.")

12: Der finale Test

Wie in dem Video zu sehen, leuchtet die grüne LED wenn ich im Bild bin, zusätzlich auch die rote LED wenn auch das Wasserglas zu sehen ist und diese gehen auch wieder aus wenn die Objekte verdeckt oder abwesend ist.
Jetzt könnte man statt LED auch ein 3,3V Relay verwenden der Motoren, Servos oder sonstige Anschlüsse steuert.

Welche Objekte soll der Raspberry Pi für dich suchen?
Was für Lösungen habt ihr damit vor umzusetzen? – Schreibt es in die Youtube-Video Kommentare.

Youtube-Video: