Die Shelly Camera habe ich auf diesem Blog bereits vorgestellt. Nun möchte ich die Kamera für ein erstes praktisches Projekt nutzen und einen Snapshot automatisch auswerten lassen.
Dafür setze ich auf YOLO und ein bereits vortrainiertes Modell. Dieses erkennt viele alltägliche Objekte direkt, sodass der Einstieg in die Bilderkennung besonders unkompliziert ist.
Hinweis: Die in diesem Beitrag verwendete Shelly Camera habe ich selbst gekauft. Der Beitrag ist nicht gesponsert. Das gezeigte Prinzip ist außerdem nicht auf die Shelly Camera beschränkt – auch Kameras wie die ESP32-CAM lassen sich dafür verwenden. Darauf gehe ich später im Beitrag und im zugehörigen YouTube-Video noch genauer ein.
Mein Testsystem – Dell OptiPlex 3050 Micro
Für die Bilderkennung nutze ich einen Dell OptiPlex 3050 Micro mit Fedora Linux und 16 GB Arbeitsspeicher. Der kompakte Rechner dient bei mir als lokales Testsystem und übernimmt später die Auswertung der Snapshots der Shelly Camera.
Damit die verwendete Hardware nachvollziehbar ist, habe ich ein kleines Bash-Skript erstellt. Dieses gibt die wichtigsten Systeminformationen zu CPU, RAM und Datenträger übersichtlich im Terminal aus.
Das Skript kannst du hier herunterladen:
Nach dem Start erhältst du eine kompakte Ausgabe der wichtigsten Hardwaredaten.
Keine NVIDIA-Grafikkarte erforderlich
Für dieses Projekt ist keine NVIDIA-Grafikkarte notwendig. Die Objekterkennung mit YOLO kann vollständig über die CPU ausgeführt werden.
Da in diesem Projekt einzelne Snapshots der Shelly Camera analysiert werden, reicht die Leistung des Dell OptiPlex 3050 Micro dafür aus. Eine dedizierte GPU wird vor allem dann interessant, wenn große Modelle, viele Bilder pro Sekunde oder komplette Videostreams in Echtzeit verarbeitet werden sollen.
Für den Einstieg in die lokale Bilderkennung genügt daher ein normaler Linux-PC mit ausreichend Arbeitsspeicher und einer aktuellen CPU.
YOLO unter Fedora installieren
Für die Objekterkennung verwende ich Ultralytics YOLO. Damit die benötigten Python-Pakete sauber vom restlichen System getrennt bleiben, erstelle ich zunächst eine virtuelle Python-Umgebung.
Zuerst prüfen wir, ob Python verfügbar ist:
python3 --version
Anschließend erstelle ich einen neuen Projektordner:
mkdir shelly-camera-yolo cd shelly-camera-yolo
Jetzt wird die virtuelle Umgebung angelegt:
python3 -m venv .venv
und aktiviert:
source .venv/bin/activate
Im Terminal sollte nun vor der Eingabeaufforderung (.venv) erscheinen.
Als Nächstes aktualisiere ich pip:
python -m pip install --upgrade pip
Danach kann Ultralytics installiert werden:
pip install -U ultralytics
Ultralytics installiert dabei auch die benötigten Abhängigkeiten wie PyTorch. Für die aktuellen YOLO-Versionen wird mindestens Python 3.8 vorausgesetzt.
Ob die Installation funktioniert hat, lässt sich anschließend einfach prüfen:
yolo checks
Damit ist die grundlegende Umgebung für unsere Objekterkennung eingerichtet.
YOLO automatisch per Shell-Skript einrichten
Wer die einzelnen Installationsschritte nicht manuell ausführen möchte, kann die Einrichtung auch mit einem kleinen Shell-Skript erledigen. Das Skript legt den Projektordner an, erstellt die virtuelle Python-Umgebung, aktualisiert pip, installiert Ultralytics und führt anschließend yolo checks aus.
Zusätzlich wird direkt das Verzeichnis images für die späteren Snapshots angelegt.
Das Skript kannst du hier verwenden:
Damit die virtuelle Python-Umgebung nach der Ausführung im aktuellen Terminal aktiv bleibt, sollte das Skript mit source gestartet werden:
source ./setup_yolo.sh
Alternativ vorher ausführbar machen:
chmod +x setup_yolo.sh
Snapshot der Shelly Camera herunterladen
Bevor wir mit der eigentlichen Objekterkennung starten, laden wir zunächst einen aktuellen Snapshot der Shelly Camera herunter.
Dafür lege ich im Projektverzeichnis einen Ordner für die Bilder an:
mkdir images
Anschließend erstelle ich die Datei:
nano download_snapshot.py
mit folgendem Inhalt:
Python-Skript zum laden eines Snapshots von der Shelly Camera
import requests
SNAPSHOT_URL = "http://192.168.178.78/camera/0/snapshot"
OUTPUT_FILE = "images/shelly-camera.jpg"
response = requests.get(SNAPSHOT_URL, timeout=10)
response.raise_for_status()
with open(OUTPUT_FILE, "wb") as file:
file.write(response.content)
print(f"Snapshot gespeichert: {OUTPUT_FILE}")
Das Skript wird anschließend gestartet mit:
python download_snapshot.py
Wenn der Abruf erfolgreich war, sollte folgende Ausgabe erscheinen:
Snapshot gespeichert: images/shelly-camera.jpg
Das Bild befindet sich nun unter:
images/shelly-camera.jpg
und kann im nächsten Schritt von YOLO analysiert werden.
Ersten Snapshot mit YOLO analysieren
Nachdem der Snapshot der Shelly Camera gespeichert wurde, können wir das Bild nun erstmals mit YOLO analysieren.
Dafür verwende ich das vortrainierte Modell yolo26n.pt:
yolo predict model=yolo26n.pt source=images/shelly-camera.jpg
Beim ersten Start wird das benötigte Modell automatisch heruntergeladen. Anschließend analysiert YOLO das Bild und sucht nach bekannten Objekten.
Zusätzlich erstellt YOLO ein Bild, in dem erkannte Objekte mit einem Rahmen und der jeweiligen Klasse markiert werden.
Das Ergebnis wird standardmäßig unter folgendem Verzeichnis gespeichert:
runs/detect/predict/
Dort befindet sich anschließend auch der analysierte Snapshot der Shelly Camera.
Für unseren ersten Test reicht bereits dieser einzelne Befehl aus. Im nächsten Schritt können wir die Erkennung per Python ausführen und die gefundenen Objekte gezielt weiterverarbeiten.
Wie gut unterscheidet YOLO ähnliche Objekte?
Um zu testen, wie gut das vortrainierte Modell ähnliche Objekte voneinander unterscheiden kann, habe ich eine Mandarine, einen Kürbis und einen Apfel vor der Shelly Camera platziert.
Mein Ziel war dabei nicht nur zu prüfen, ob überhaupt Objekte erkannt werden, sondern wie sauber YOLO zwischen ähnlich geformten und farblich verwandten Gegenständen unterscheidet.
Gerade hier zeigt sich eine wichtige Grenze vortrainierter Modelle: YOLO kann nur Klassen sicher erkennen, die im verwendeten Trainingsdatensatz enthalten sind. Ein Apfel gehört zu den bekannten Standardklassen, eine Mandarine oder ein Kürbis dagegen nicht unbedingt als eigene Klasse.
Dadurch kann es passieren, dass solche Objekte entweder gar nicht erkannt oder einer ähnlichen bekannten Klasse zugeordnet werden.
Vergleich mit bekannten Objektklassen
Nachdem der Kürbis im ersten Test nicht zuverlässig erkannt wurde, habe ich ihn durch eine Banane ersetzt. Damit befinden sich nun drei Objekte im Bild, die vom vortrainierten Modell grundsätzlich bekannt sind: Banane, Orange und Apfel.
Die Mandarine wird dabei der Klasse orange zugeordnet, was für diesen Test völlig nachvollziehbar ist.
Die Ergebnisse zeigen deutlich, dass die Erkennung bei bekannten Objektklassen wesentlich zuverlässiger funktioniert:
| Modell | Banane | Mandarine (orange) | Apfel |
|---|---|---|---|
| YOLO26n | 0,81 | 0,83 | 0,74 |
| YOLO26s | 0,93 | 0,88 | 0,91 |
| YOLO26m | 0,94 | 0,94 | 0,87 |
Besonders interessant ist, dass die größeren Modelle s und m bei den meisten Objekten höhere Confidence-Werte erreichen. Gleichzeitig zeigt der Test aber auch, dass ein größeres Modell nicht zwangsläufig bei jedem einzelnen Objekt den höchsten Wert liefert.
Für diesen Anwendungsfall liefern bereits alle drei Modelle brauchbare Ergebnisse.
ESP32-CAM als alternative Bildquelle
Die Shelly Camera ist für dieses Projekt nicht zwingend erforderlich. Auch eine ESP32-CAM kann als Bildquelle genutzt werden, sofern sie einen Snapshot per HTTP bereitstellt.
Gerade zum Ausprobieren ist die ESP32-CAM interessant, weil sie nur einen Bruchteil einer Shelly Camera kostet. Wer also einfach erste Erfahrungen mit Bilderkennung und YOLO sammeln möchte, bekommt damit eine sehr günstige und flexible Alternative.
In meinem Fall ist der aktuelle Snapshot über folgende URL erreichbar:
http://192.168.178.79/capture
Im Python-Skript muss dafür lediglich die Snapshot-URL angepasst werden:
SNAPSHOT_URL = "http://192.168.178.79/capture"
Die Bildqualität der ESP32-CAM lässt sich über die Weboberfläche konfigurieren, die direkt über die IP-Adresse erreichbar ist:
http://192.168.178.79
Dort können je nach Firmware unter anderem Auflösung und Bildqualität angepasst werden. Für die Objekterkennung lohnt es sich, hier etwas zu experimentieren, da die Bildqualität einen direkten Einfluss auf das Ergebnis haben kann.
Objekterkennung mit der ESP32-CAM testen
Nachdem der Snapshot der ESP32-CAM gespeichert wurde, kann dieser genauso wie das Bild der Shelly Camera mit den drei YOLO-Modellen analysiert werden:
yolo predict model=yolo26n.pt source=images/esp32-camera.jpg yolo predict model=yolo26s.pt source=images/esp32-camera.jpg yolo predict model=yolo26m.pt source=images/esp32-camera.jpg
Auch hier habe ich wieder Banane, Mandarine und Apfel als Testobjekte verwendet. Die Ergebnisse fallen jedoch deutlich anders aus als zuvor mit der Shelly Camera:
| Modell | Banane | Mandarine (orange) | Apfel |
|---|---|---|---|
| YOLO26n | nicht erkannt | 0,36 | 0,73 |
| YOLO26s | 0,31 | 0,34 | 0,51 |
| YOLO26m | als donut 0,28 | 0,75 | 0,77 |
Besonders auffällig ist die Banane. Während yolo26s sie noch mit einer relativ niedrigen Confidence von 0,31 erkennt, findet yolo26n sie gar nicht. yolo26m ordnet sie sogar fälschlicherweise als donut ein.
Die ESP32-CAM liefert in meinem Test ein sichtbar anderes Ausgangsbild als die Shelly Camera. Auflösung, Bildschärfe, Belichtung und die Einstellungen der Kamera können die Objekterkennung beeinflussen. Deshalb lohnt es sich, die Kameraeinstellungen über die Weboberfläche anzupassen und verschiedene Konfigurationen auszuprobieren.
Das zeigt gleichzeitig einen wichtigen Punkt: Ein größeres YOLO-Modell garantiert nicht automatisch ein besseres Ergebnis, wenn bereits das Ausgangsbild ungünstiger ist.
YOLO-Ergebnis in Node-RED weiterverarbeiten
Bisher habe ich YOLO hauptsächlich über die Kommandozeile getestet. Für eine praktische Anwendung möchte ich die Objekterkennung jedoch automatisieren. Dafür nutze ich Node-RED.
Node-RED ruft zunächst den Snapshot der ESP32-CAM ab und speichert diesen als Bilddatei. Anschließend wird über eine exec-Node mein Python-Skript gestartet, welches das Bild mit YOLO analysiert.
Neben dem markierten Ergebnisbild liefert das Skript die erkannten Objekte als JSON zurück. So kann Node-RED beispielsweise direkt prüfen, ob ein bestimmtes Objekt erkannt wurde.
Fazit und Ausblick
Die ersten Tests zeigen, dass sich eine lokale Objekterkennung mit überschaubarem Aufwand umsetzen lässt. Dabei braucht es weder eine spezielle KI-Kamera noch eine leistungsfähige NVIDIA-Grafikkarte. Die Kamera liefert lediglich das Bild – die eigentliche Auswertung übernimmt YOLO auf meinem Dell OptiPlex 3050 Micro.
Besonders interessant fand ich den Vergleich der verschiedenen YOLO-Modelle sowie die Unterschiede zwischen der Shelly Camera und der deutlich günstigeren ESP32-CAM. Dabei wurde auch deutlich, dass nicht nur die Größe des Modells, sondern ebenso die Qualität des Ausgangsbildes einen großen Einfluss auf das Ergebnis hat.
Mit der Anbindung an Node-RED lässt sich die Objekterkennung außerdem direkt in eigene Automatisierungen integrieren. Statt nur ein Bild mit markierten Objekten zu erzeugen, können die Ergebnisse als strukturierte Daten weiterverarbeitet werden.
Damit ist für mich aber noch nicht Schluss. Als nächsten Schritt möchte ich das bestehende Setup erweitern und mich mit der Erkennung von Fahrzeugkennzeichen beschäftigen. Dabei soll zunächst ein Kennzeichen im Kamerabild lokalisiert und anschließend dessen Text ausgelesen werden.
Die vorhandene Architektur aus Kamera, Node-RED, Python und lokaler Bildverarbeitung kann dafür weitgehend weiterverwendet werden. Genau darauf werde ich in einem der nächsten Beiträge aufbauen.
Letzte Aktualisierung am: 20. September 2026
