Die Sicherheit deines Zuhauses oder Geschäfts ist von grösster Bedeutung. Während professionelle Sicherheitssysteme teuer sein können, bietet dir ein DIY-Sicherheitssystem mit einem Raspberry Pi und künstlicher Intelligenz (KI) eine kostengünstige und dennoch leistungsstarke Alternative. In diesem Artikel zeigen wir dir, wie du dein eigenes intelligentes Videoüberwachungssystem aufbauen kannst, das verdächtige Aktivitäten erkennt und dich benachrichtigt.
Warum ein DIY-Sicherheitssystem mit Raspberry Pi?
Ein Raspberry Pi ist ein kleiner, kostengünstiger Computer, der sich perfekt für Projekte im Bereich des Internets der Dinge (IoT) eignet. Er ist leistungsstark genug, um KI-Modelle auszuführen, die Videostreams analysieren und ungewöhnliche Ereignisse erkennen können. Hier sind einige Vorteile eines DIY-Sicherheitssystems:
- Kosteneffizienz: Im Vergleich zu kommerziellen Systemen sparst du erheblich.
- Anpassbarkeit: Du kannst das System an deine spezifischen Bedürfnisse anpassen.
- Datenschutz: Du behältst die Kontrolle über deine Daten, da sie nicht über Cloud-Dienste laufen müssen.
- Lernen und Spass: Es ist ein grossartiges Projekt, um deine technischen Fähigkeiten zu verbessern.
Benötigte Hardware und Software
Bevor wir loslegen, benötigst du die folgende Hardware und Software:
- Raspberry Pi: Ein Raspberry Pi 4 mit mindestens 4 GB RAM wird empfohlen. Ältere Modelle funktionieren möglicherweise auch, aber die Leistung könnte geringer sein.
- MicroSD-Karte: Eine 32 GB oder grössere microSD-Karte zur Installation des Betriebssystems.
- Raspberry Pi Kamera: Eine Raspberry Pi Kamera (z.B. Camera Module v2 oder HQ Camera) oder eine USB-Webcam.
- Netzteil: Ein passendes Netzteil für deinen Raspberry Pi.
- Gehäuse (optional): Ein Gehäuse zum Schutz deines Raspberry Pi.
- Internetverbindung: Eine stabile Internetverbindung für die Installation von Software und den Fernzugriff.
- Betriebssystem: Raspberry Pi OS (ehemals Raspbian)
- Python: Python ist die Hauptprogrammiersprache, die wir verwenden werden.
- TensorFlow Lite: Eine optimierte Version von TensorFlow für ressourcenbeschränkte Geräte wie den Raspberry Pi.
- OpenCV: Eine Bibliothek für Computer Vision, die wir zur Verarbeitung von Videostreams verwenden werden.
- Objekterkennungsmodell: Ein vortrainiertes KI-Modell zur Erkennung von Objekten im Videostream (z.B. MobileNet SSD).
Schritt-für-Schritt-Anleitung zur Installation und Konfiguration
Schritt 1: Raspberry Pi OS installieren
Lade die neueste Version von Raspberry Pi OS von der offiziellen Raspberry Pi Website herunter. Verwende den Raspberry Pi Imager, um das Betriebssystem auf die microSD-Karte zu schreiben. Stecke die microSD-Karte in deinen Raspberry Pi und starte ihn.
Schritt 2: Raspberry Pi konfigurieren
Nach dem Starten von Raspberry Pi OS musst du einige grundlegende Konfigurationen vornehmen:
- Verbinde dich mit deinem WLAN-Netzwerk.
- Aktiviere SSH, um dich aus der Ferne mit dem Raspberry Pi zu verbinden (empfohlen).
- Aktualisiere das System mit den folgenden Befehlen im Terminal:
- Aktiviere die Kamera-Schnittstelle, falls du eine Raspberry Pi Kamera verwendest.
sudo apt update
sudo apt upgradeSchritt 3: Python und notwendige Bibliotheken installieren
Standardmässig ist Python auf Raspberry Pi OS installiert. Installiere die benötigten Bibliotheken mit pip, dem Python-Paketmanager:
sudo apt install python3-pip
pip3 install opencv-python
pip3 install tflite-runtime
pip3 install pillowStelle sicher, dass du die neueste Version von `tflite-runtime` verwendest, um Leistungsprobleme zu vermeiden.
Schritt 4: Objekterkennungsmodell herunterladen
Lade ein vortrainiertes Objekterkennungsmodell herunter. Ein beliebtes Modell für den Raspberry Pi ist MobileNet SSD. Du findest es auf TensorFlow Hub oder anderen Quellen für vortrainierte Modelle. Erstelle einen Ordner auf deinem Raspberry Pi, z.B. `/home/pi/security_cam/models`, und speichere das Modell dort.
Lade beispielsweise die `detect.tflite` und `labelmap.txt` Dateien herunter und speichere sie im erwähnten Ordner.
Schritt 5: Python-Skript erstellen
Erstelle ein Python-Skript (z.B. `security_cam.py`), das den Videostream von der Kamera erfasst, das Objekterkennungsmodell ausführt und dich benachrichtigt, wenn verdächtige Objekte erkannt werden.
Hier ist ein Beispiel-Code:
import cv2
import tflite_runtime.interpreter as tflite
import numpy as np
from PIL import Image
# Modell laden
MODEL_PATH = '/home/pi/security_cam/models/detect.tflite'
LABEL_PATH = '/home/pi/security_cam/models/labelmap.txt'
interpreter = tflite.Interpreter(model_path=MODEL_PATH)
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
# Labels laden
with open(LABEL_PATH, 'r') as f:
labels = [line.strip() for line in f.readlines()]
# Kamera initialisieren
VIDEO_SOURCE = 0 # 0 für die Standard-Webcam, 1 für eine zweite, etc.
cap = cv2.VideoCapture(VIDEO_SOURCE)
if not cap.isOpened():
raise IOError("Cannot open webcam")
# Schleife zur Verarbeitung des Videostreams
while True:
ret, frame = cap.read()
if not ret:
break
# Bild vorbereiten für das Modell
image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
resized_image = image.resize((300, 300))
input_data = np.expand_dims(resized_image, axis=0)
# Typ korrekt formatieren (wichtig!)
input_data = (np.float32(input_data) - 127.5) / 127.5
interpreter.set_tensor(input_details[0]['index'], input_data)
# Objekterkennung ausführen
interpreter.invoke()
boxes = interpreter.get_tensor(output_details[0]['index'])[0]
classes = interpreter.get_tensor(output_details[1]['index'])[0]
scores = interpreter.get_tensor(output_details[2]['index'])[0]
# Ergebnisse verarbeiten
for i in range(len(scores)):
if ((scores[i] > 0.5) and (scores[i] <= 1.0)): #Wahrscheinlichkeitsschwelle
#Bounding Box Koordinaten und Klasse extrahieren
ymin = int(max(1,(boxes[i][0] * frame.shape[0])))
xmin = int(max(1,(boxes[i][1] * frame.shape[1])))
ymax = int(min(frame.shape[0],(boxes[i][2] * frame.shape[0])))
xmax = int(min(frame.shape[1],(boxes[i][3] * frame.shape[1])))
class_name = labels[int(classes[i])]
label = '%s: %d%%' % (class_name, int(scores[i]*100)) #Label erzeugen
labelSize, baseLine = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 2) #Schriftgrösse anpassen
label_ymin = max(ymin, labelSize[1] + 10) #Höhe der Labelbox berechnen
cv2.rectangle(frame, (xmin, label_ymin-labelSize[1]-10), (xmax, label_ymin+baseLine-10), (255, 255, 255), cv2.FILLED) #Hintergrund für Label
cv2.rectangle(frame, (xmin,ymin), (xmax,ymax), (10, 255, 0), 2) #Bounding Box
cv2.putText(frame, label, (xmin, label_ymin-7), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 2) #Text
print(f"Objekt erkannt: {class_name} mit Sicherheit: {scores[i]}")
#Anzeige des Frames mit Bounding Boxes
cv2.imshow('Raspberry Pi Security Cam', frame)
#Beenden des Skripts mit 'q'
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# Aufräumen
cap.release()
cv2.destroyAllWindows()
Wichtiger Hinweis: Dieser Code ist ein grundlegendes Beispiel. Für eine produktive Anwendung solltest du Fehlerbehandlung, Konfigurationsoptionen (z.B. Schwellwerte für die Erkennung, Region of Interest), Benachrichtigungen (E-Mail, SMS) und die Möglichkeit zur Speicherung der Aufnahmen hinzufügen.
Schritt 6: Skript ausführen und testen
Führe das Skript im Terminal aus:
python3 security_cam.pyDu solltest nun den Videostream von deiner Kamera sehen. Wenn das System Objekte erkennt, werden diese mit einem Rahmen und einer Bezeichnung markiert.
Schritt 7: Automatischer Start beim Systemstart (optional)
Um das Skript automatisch beim Systemstart auszuführen, kannst du einen systemd-Dienst erstellen. Erstelle eine Datei `security_cam.service` in `/etc/systemd/system/` mit folgendem Inhalt:
[Unit]
Description=Raspberry Pi Security Camera
[Service]
User=pi
WorkingDirectory=/home/pi/security_cam
ExecStart=/usr/bin/python3 security_cam.py
Restart=on-failure
[Install]
WantedBy=multi-user.target
Aktiviere und starte den Dienst:
sudo systemctl enable security_cam.service
sudo systemctl start security_cam.serviceVerbesserungen und Erweiterungen
Es gibt viele Möglichkeiten, dein DIY-Sicherheitssystem zu verbessern und zu erweitern:
- Benachrichtigungen: Integriere E-Mail- oder SMS-Benachrichtigungen, wenn verdächtige Aktivitäten erkannt werden.
- Speicherung: Speichere Videos auf einer externen Festplatte oder in der Cloud.
- Bewegungserkennung: Kombiniere KI mit Bewegungserkennung, um die Leistung zu verbessern.
- Gesichtserkennung: Implementiere Gesichtserkennung, um bekannte Personen zu identifizieren.
- Fernzugriff: Richte einen Fernzugriff auf den Videostream ein, um ihn von überall aus zu überwachen.
- Integration mit Home Assistant: Integriere dein System in Home Assistant für eine zentrale Steuerung deiner Smart-Home-Geräte.
Sicherheitshinweise
Denke daran, dein DIY-Sicherheitssystem ordnungsgemäss zu sichern:
- Ändere das Standardpasswort deines Raspberry Pi.
- Aktiviere die Firewall (z.B. ufw).
- Halte das Betriebssystem und die Software auf dem neuesten Stand.
- Verwende sichere Passwörter für alle Dienste und Konten.
Fazit
Mit einem Raspberry Pi, etwas KI und ein wenig Programmieraufwand kannst du ein leistungsstarkes und anpassbares DIY-Sicherheitssystem erstellen. Dieses Projekt ist nicht nur kostengünstig, sondern auch eine grossartige Möglichkeit, deine technischen Fähigkeiten zu verbessern und die Kontrolle über deine Sicherheit zu behalten. Probiere es aus und gestalte dein eigenes intelligentes Zuhause!