[Erfahrungsbericht + Vorschlag] Universelle lokale Videoüberwachung in Gladys — go2rtc + Frigate (Person/Hund/Pferd-Erkennung... ohne Cloud)

Hallo zusammen! :wave:

Ich möchte eine vollständige Erfahrungsmeldung teilen, die sich in ein Integrationsprojekt für Gladys verwandelt hat. Auf dem Programm steht: Wie ich eine Kamera, die TP-Link absichtlich eingeschränkt hat (kein RTSP, kein ONVIF), vollständig lokal zum Laufen gebracht habe, mit KI-Objekterkennung (Person, Hund, Katze… und sogar Pferd :horse:), alles auf einem Mini-PC, der bereits 2 Gladys und einen Home Assistant betreibt. Und am Ende der Entwicklungsvorschlag, den ich starten möchte.

Haltet euch fest, es ist etwas lang, aber alles ist reproduzierbar. :coffee:


:warning: Das Ausgangsproblem

Ich habe mehrere Tapo-Kameras, darunter eine C660 (4K, Schwenk/Neige, Solar/Batterie — aber bei mir an die Steckdose angeschlossen, die Batterie dient nur als Notfallreserve).

Ich wollte das Gleiche wie alle anderen hier: Meine Kameras steuern und Benachrichtigungen über Erkennungen (Person, Tier…) lokal in Gladys / Node-RED über MQTT erhalten, ohne von der TP-Link-Cloud abhängig zu sein.

Erste Hürde: Bei der gesamten Batterie/Solar-Reihe (C425, C460, C660, C645D, D230…), deaktiviert TP-Link RTSP und ONVIF. Das wird vom Hersteller bewusst so gemacht und dokumentiert: „Energiesparen“. Dass die Kamera dauerhaft an der Steckdose hängt, ändert nichts, das entscheidet die Firmware. :man_facepalming:

Eine Überprüfung, die keinen Zweifel lässt:

$ nmap -Pn -p 443,554,2020,8800 10.6.0.222

PORT     STATE  SERVICE
443/tcp  open   https
554/tcp  closed rtsp       ← RTSP geschlossen
2020/tcp closed onvif      ← ONVIF geschlossen
8800/tcp open   ???        ← hmm... 👀

RTSP und ONVIF geschlossen… aber ein mysteriöser Port 8800 offen.

Zweite Hürde, die auch für Tapo-Kameras mit RTSP (meine C520WS zum Beispiel) gilt: Die Meldung von Erkennungsereignissen über ONVIF ist bei mehreren Modellen kaputt (bekannter Firmware-Bug). Also auch mit RTSP keine zuverlässigen lokalen Benachrichtigungen.

:bulb: Die Umgehung: go2rtc spricht „Tapo“

Der Port 8800 ist das proprietäre TP-Link-Protokoll — das, das die Tapo-App verwendet. Und es stellt sich heraus, dass go2rtc (AlexxITs Video-Swiss-Army-Knife, eingebettet in Frigate UND in Home Assistant) es nativ über eine Quelle tapo:// sprechen kann.

Die vollständige Architektur wird:

Kamera (tapo://, rtsp://, onvif://, ...) → go2rtc → Frigate (KI-Erkennung) → MQTT → Gladys / Node-RED

Und der Schlüsselpunkt: Frigate übernimmt die Objekterkennung, nicht die Kamerasoftware. Also kein ONVIF mehr nötig, kein Cloud-Zugriff, und eine bessere Erkennung als die von TP-Link — die Tapo-App sagt mir „Tier“ für alles, Frigate unterscheidet person, dog, cat, horse (COCO-Labelmap, 91 Klassen). Ich brauche die Pferde genau zu erkennen, sagen wir mal, das ändert alles. :racehorse:

:hammer_and_wrench: Die Fallstricke (um euch Stunden an Debugging zu ersparen)

Es hat nicht beim ersten Mal funktioniert, und jede Falle ist es wert, dokumentiert zu werden:

1. Das Passwort muss URL-encodiert sein. Die Quelle ist tapo://PASSWORT@IP mit dem Passwort für Ihr Tapo-Cloud-Konto (kein „Kamera-Konto“ bei diesen Modellen). Wenn Ihr Passwort #, ^, %, @… enthält, müssen Sie es encodieren (# → %23, usw.), sonst kürzt go2rtc die URL stillschweigend ab. Tipp:

bash

python3 -c "import urllib.parse,getpass; print(urllib.parse.quote(getpass.getpass('mdp: '), safe=''))"

2. Der Haupt-4K-Stream = schwarzer Bildschirm. Bekannter Bug (SPS/PPS nicht weitergeleitet, siehe go2rtc #2202): Die Kamera sendet das Video, aber go2rtc kann es nicht parsen. Der Substream funktioniert perfekt:

tapo://ENCODIERTES_PASSWORT@10.6.0.222?channel=0&subtype=1

640×360, das sieht fürs Auge nicht gut aus, aber es ist genau das, was Frigate für die Erkennung braucht (die Modelle arbeiten ohnehin mit 300-640 px). Das 4K bleibt auf der SD-Karte der Kamera für die Wiedergabe.

3. Die schlechten Zeitstempel (DIE Falle). Der tapo-Stream erzeugt nicht monotone DTS → ffmpeg läuft auf 190 % CPU, der Frigate-Watchdog tötet es in einer Schleife, es werden keine Clips aufgezeichnet. Der Fix, der alles repariert hat:

yaml

input_args: -avoid_negative_ts make_zero -fflags +genpts+discardcorrupt -rtsp_transport tcp -use_wallclock_as_timestamps 1

Der Schlüssel ist -use_wallclock_as_timestamps 1: ffmpeg ignoriert die Zeitstempel der Quelle und generiert sie neu.

4. Der Intel-iGPU ändert alles. Mein Server ist ein bescheidener Beelink U59 (Celeron N5105), der bereits HA + 2 Gladys hostet. Als CPU-Detektor war er auf den Knien (86 % System). Nach Aktivierung von OpenVINO auf dem iGPU + VAAPI-Decodierung:

Metrik CPU iGPU (OpenVINO + VAAPI)
Inferenz 94,6 ms 15,8 ms
Prozess-Detektor 191,8 % 8,5 %
System-CPU 86 % 22 %
Verlorene Frames 7/s 0

Ein Celeron mit 22 % CPU, der Echtzeit-Objekterkennung neben HA und 2 Gladys durchführt. :exploding_head:

:white_check_mark: Das Ergebnis

Über MQTT veröffentlicht Frigate alles, wovon man träumt:

frigate/c660/person            → 1 / 0  (binär, perfekt für Gladys)
frigate/c660/dog               → 1 / 0
frigate/events                 → reicher JSON (Label, Score, Box, Trajektorie, Zonen...)
frigate/reviews                → Benachrichtigungen mit Thumbnail
frigate/stats                  → vollständige Gesundheitsdaten (fps, Inferenz, Speicher...)

Erkennung in der Praxis validiert (Person mit 0,93 Score, Hund erkannt, wo Tapo „Tier“ sagt), Clips aufgezeichnet, Snapshots, kein Cloud. Eine Kamera, die „offiziell nicht integrierbar“ ist, die lokal besser funktioniert als die „kompatiblen“ Modelle. :muscle:

:gear: Vollständige validierte Konfigurationen (docker-compose + Frigate-Konfiguration) — klicken Sie zum Aufklappen

docker-compose.yml:

yaml

services:
  frigate:
    container_name: frigate
    image: ghcr.io/blakeblackshear/frigate:stable
    restart: unless-stopped
    shm_size: "256mb"
    devices:
      - /dev/dri/renderD128:/dev/dri/renderD128
    volumes:
      - ./config:/config
      - ./storage:/media/frigate
      - type: tmpfs
        target: /tmp/cache
        tmpfs:
          size: 1000000000
    ports:
      - "8971:8971"   # UI (HTTPS ab Version 0.17!)
      - "8554:8554"   # RTSP-Restream
      - "1984:1984"   # go2rtc

config/config.yml:

yaml

mqtt:
  enabled: true
  host: <Ihr_Mosquitto>
  user: xxx
  password: xxx

detectors:
  ov:
    type: openvino
    device: GPU

model:
  width: 300
  height: 300
  input_tensor: nhwc
  input_pixel_format: bgr
  path: /openvino-model/ssdlite_mobilenet_v2.xml
  labelmap_path: /openvino-model/coco_91cl_bkgr.txt

go2rtc:
  streams:
    c660:
      - tapo://URL_ENCODIERTES_PASSWORT@10.6.0.222?channel=0&subtype=1

cameras:
  c660:
    ffmpeg:
      hwaccel_args: preset-vaapi
      inputs:
        - path: rtsp://127.0.0.1:8554/c660
          input_args: -avoid_negative_ts make_zero -fflags +genpts+discardcorrupt -rtsp_transport tcp -use_wallclock_as_timestamps 1
          roles: [detect, record]
    detect:
      enabled: true
      fps: 5
      width: 640
      height: 360
    objects:
      track: [person, dog, cat, horse]
    record:
      enabled: true
      retain:
        days: 7
        mode: motion
    snapshots:
      enabled: true
      retain:
        default: 14

Betriebsanmerkungen:

  • Frigate 0.17: Die UI ist HTTPS auf Port 8971 (selbstsigniertes Zertifikat), Admin-Konto wird beim ersten Start generiert (Passwort in den Logs).
  • shm_size: 128 MB reichen nicht aus, nicht einmal für 1 Kamera.
  • Die Tapo-Kameras begrenzen gleichzeitige Streams → immer über go2rtc konsumieren (der 1 Verbindung bündelt), nie direkt.
  • Kleine periodische Warnung connection reset by peer am Port 8800: Die Kamera trennt gelegentlich, go2rtc verbindet sich automatisch wieder. Nicht blockierend.
---

:rocket: Und dannenant : Vorschlag zur Integration von Gladys

Alles funktioniert, aber seien wir ehrlich: zwischen nmap, URL-Encoding, ffmpeg-Input-Args und der OpenVINO-Konfiguration, das ist nicht für den Durchschnittsbürger zugänglich. Und genau das ist die Art von Komplexität, die Gladys verstecken kann. :heart:

Ich plane daher eine Integration „Lokale Videoüberwachung“ (neuer Dienst oder Erweiterung von rtsp-camera, zu diskutieren), deren Prinzip darin besteht, nicht das Rad neu zu erfinden:

  • go2rtc = Protokollabstraktionsschicht (es spricht rtsp://, tapo://, onvif://, Ring, Nest, Dahua, USB… und wird von AlexxIT + einer großen Community gepflegt). Eine Integration = alle Kameras.
  • Frigate = Objekterkennung + Aufnahmen + MQTT.
  • Gladys = Orchestrierung, einfache Konfiguration und Bereitstellung der Funktionen.

Was die Integration tun würde

  1. Verwaltung der Frigate/go2rtc-Container über die Gladys-Benutzeroberfläche (Installation, Start, Neustart) — nach demselben Muster wie das, was bereits für Zigbee2MQTT existiert.
  2. Intelligente automatische Konfiguration: Erkennung der Hardware (Intel iGPU vorhanden? → OpenVINO + VAAPI; sonst CPU), Berechnung der shm_size entsprechend der Anzahl der Kameras, stabile Standardeinstellungen — alles überschreibbar im Expertenmodus.
  3. Einfache Kamerahinzufügung: Name, Typ (RTSP / Tapo / ONVIF…), IP, Passwort (automatisch verschlüsselt!), Auswahl der zu erkennenden Objekte (person, dog, cat, horse… Mehrfachauswahl). Die Integration generiert die Frigate-Konfiguration und wendet bekannte Korrekturen an (Tapo-Substream, input_args-Timestamps…) ohne dass der Benutzer wissen muss, dass sie existieren.
  4. Automatisch erstellte Gladys-Features pro Kamera:
  • die klassische Live-Kamera;
  • ein Erkennungsbinär pro Objekttyp (frigate/<cam>/person → Gladys-Anwesenheits-Sensor → Szenen!);
  • eine „Bildkamera“ pro Typ: das letzte erfasste Bild jeder Erkennung (wahrscheinlich ein neuer Bild-Feature-Typ, ohne Live-Ansicht — zu diskutieren).
  1. Gesundheit: Status pro Kamera, Reconnect-Zähler, Frigate-Statistiken.

Offene Fragen für die Community (und @pierre-gilles :slight_smile:)

  • Neuer Dienst oder Erweiterung von rtsp-camera? Meine Intuition: neuer Dienst (der Umfang ist sehr unterschiedlich), aber das Bestehende sollte der einfache Weg für diejenigen bleiben, die nur einen RTSP-Stream wollen.
  • Neuer Feature-Typ „Bildkamera nur“ (Anzeige des letzten Bildes, kein Live-Player): Erscheint Ihnen das die richtige Modellierung für „letzte Erkennung vom Typ X“?
  • Politik der Begleitcontainer: Frigate bringt seinen eigenen go2rtc mit, daher reicht ein Container. OK, dem Z2M-Muster zu folgen?
  • Live-Ansicht: Integration des Web-Components video-stream.js von go2rtc (WebRTC/MSE) mit Fallback-Snapshots für unzuverlässige Streams. Frage des Proxys über den Gladys-Server zu untersuchen (Mixed Content HTTPS/HTTP).

Ich beginne die Entwicklung mit einer Analysephase des Bestehenden, dann einem MVP (Container + generische RTSP-Kamera + MQTT-Erkennungsbinär), dann den erweiterten Quellen (tapo://, onvif://) und dem Live-Betrieb. PRs klein und aufgeteilt, wie üblich.

Alle Rückmeldungen sind willkommen: Anwendungsfälle, Kameras, die Sie gerne unterstützt sehen würden, Meinungen zu den oben genannten Fragen… Und wenn einige den manuellen Setup testen möchten, während sie warten, sind die vollständigen Konfigurationen im obigen Auszug — ich beantworte Fragen! :raised_hands:

Bis bald, Terdious

Wichtiger Zusatz, weil der Fall meiner Tapo C520WS gut zeigt, dass dieser Ansatz nicht nur für gebridgte Kameras ohne RTSP gilt. :point_down:

Der Fall C520WS: RTSP OK… aber lokale Erkennung unbrauchbar

Die C520WS ist eine kabelgebundene Kamera, also theoretisch die ideale Situation: RTSP und ONVIF offiziell unterstützt, Bild und Live-Stream funktionieren ohne Umwege (rtsp://user:pass@IP/stream1, normales Kamerakonto in der App).

Aber… die Übertragung der Erkennungsereignisse über ONVIF ist auf diesem Modell auf Firmware-Ebene kaputt :sob: Das Symptom ist bei mehreren Nutzern dokumentiert: Die ONVIF-Verbindung wird ~10 Sekunden nach der PullMessage-Anfrage getrennt, obwohl die Ereignisse in der Tapo-App erscheinen (und Modelle wie die C110/C210 sie korrekt senden). TP-Link hat Firmware-Updates veröffentlicht, die das Problem beheben sollen (C520WS V1: 1.3.2, V2: 1.1.1), aber die Rückmeldungen bleiben zufällig.

Ergebnis: Ich habe den Videostream lokal, aber keine zuverlässige Möglichkeit, lokal zu erkennen, WANN etwas erkannt wird und WAS. Das ist aber genau das Kernanliegen für die Hausautomatisierung…

Warum die Architektur go2rtc + Frigate das auch löst

Genau hier zeigt sich der Sinn des Ansatzes aus dem Beitrag: Da die Erkennung von Frigate (am RTSP-Stream) durchgeführt wird, wird das ONVIF-Problem der Kamera… völlig irrelevant. Wir brauchen nicht, dass die Firmware uns ihre Ereignisse schickt:

  • nativen RTSP-Stream → Frigate → Erkennung person / dog / cat / horse (mein echter Bedarf bei dieser Kamera, die eine Zone überwacht, in der Pferde vorbeikommen — die Tapo-App kann nur „Tier“ anzeigen :horse:);
  • reiche Ereignisse über MQTT (frigate/c520ws/person, frigate/events mit Score, Position, Trajektorie…) → direkt nutzbar in Gladys;
  • und als Kirsch obendrauf: Die Pipeline ist streng identisch mit der der C660. Eine einzige Architektur für die „unmögliche“ Kamera UND die „kompatible, aber fehlerhafte“ Kamera. Genau das bestärkt mich in der Idee einer einheitlichen Integration.

Und die PTZ-Steuerung?

Die C520WS ist motorisiert, und langfristig möchte ich sie auch von Gladys aus bewegen können (Bereich verfolgen, Presets…). Gute Nachricht: Während das ONVIF-Eventing auf diesem Modell kaputt ist, funktioniert das ONVIF-PTZ. Zwei Ansätze, die ich evaluieren werde:

  1. ONVIF PTZ über Frigate: Frigate kann die PTZ von ONVIF-Kameras steuern (Block onvif: in der Kamerakonfiguration, Port 2020 bei Tapo) — das bliebe im selben Tool;
  2. pytapo direkt (die lokale Tapo-API, Port 443): umfassender (Presets, Patrouille, Sirene, Privacy-Modus…), das ist die Bibliothek, die die HA-Integration Tapo Control verwendet.

Das wird Teil der Überlegungen zur Integration sein: Die Erkennung läuft in jedem Fall über Frigate/MQTT, aber die Steuerung (PTZ, Sirene…) könnte je nach Marke vielleicht einen dedizierten Kanal verdienen. Das muss auf der Features-Seite von Gladys sauber modelliert werden (Knöpfe/Richtungen?).

Nächster Schritt

Ich werde bald die Tests an der C520WS starten: Integration in denselben Frigate wie die C660 (der Beelink hat jetzt genug Leistung :muscle:), Erkennung von horse unter realen Bedingungen, dann erste PTZ-Tests. Vollständiger Bericht hier, sobald es erledigt ist — mit Zahlen und möglichen Fallstricken, wie bei der C660.

Wenn hier noch andere Tapo-Kabelkameras (C210, C310, C320WS, C520WS…) haben und das ONVIF-Verhalten ihrer Firmware vergleichen wollen, bin ich interessiert! :raised_hands:

Ich habe eine C610 mit Akku und es hat mich immer gestört, dass es bei dieser Art von Kamera keinen RTSP gibt.
Falls nötig habe ich auch eine C500 und eine C210, also könnte ich problemlos testen.

Super!!

Bisher habe ich alles außer Gladys getestet, also starte ich jetzt Claude Fable auf dem Dev (um meine Credits heute Abend zu verbrauchen ^^)!!

Ich halte dich auf dem Laufenden, wenn ich etwas zum Testen habe!!

Bei mir läuft Frigate auf einem dedizierten Mini-PC, also werde ich das ganz genau verfolgen.
Dazu ein paar Fragen:

  • Viele Frigate-Nutzer wie ich nutzen einen Google Coral (auch wenn das in letzter Zeit seltener der Fall ist), sollte man das nicht berücksichtigen?
  • Ich habe Reolink-Kameras, deren Konfiguration für Frigate manchmal mühsam war. Wenn die Integration in Gladys möglichst benutzerfreundlich sein soll, sollte man die Bearbeitung der YAML-Datei erleichtern, sonst verlieren wir unterwegs Leute ^^

Das sind meine ersten Fragen!

Danke @guim31, das sind genau die beiden richtigen Fragen — und sie berühren den Kern des Designs. Ich antworte Punkt für Punkt. :point_down:

1. Google Coral: Ja, und es ist sogar priorisiert

Absolut, und um präzise zu sein: Coral ist besser als das, was ich zu Hause laufen habe. Mein OpenVINO auf iGPU läuft mit ~15,8 ms Inferenz; ein Coral liegt typischerweise bei 6-10 ms, wobei der CPU vollständig entlastet wird. Es wäre absurd, es nicht zu unterstützen.

Bei Frigate ist es eine einfache Wahl des Detektors:

yaml

# Coral USB
detectors:
  coral:
    type: edgetpu
    device: usb

# Coral M.2 / PCIe
detectors:
  coral:
    type: edgetpu
    device: pci

mit der entsprechenden Geräte-Montage im Container (/dev/bus/usb bei USB, /dev/apex_0 bei PCIe).

Was ich für den Teil „automatische Hardwarekonfiguration“ plane, ist eine Kaskade der Erkennung bei der Installation:

  1. Coral erkannt (USB oder PCIe) → Detektor edgetpu :white_check_mark:
  2. Sonst Intel iGPU / GPU verfügbar → Detektor openvino
  3. Sonst → CPU-Detektor + ehrliche Warnung über die Grenzen

… alles manuell überschreibbar natürlich (Expertenmodus), weil die automatische Erkennung nicht alles erraten kann.

:bulb: Wichtige Nuance, die in deine Richtung geht: Erkennung ≠ Decodierung. Coral führt die Inferenz durch, aber die Videodecodierung bleibt auf dem CPU, wenn keine Hardwarebeschleunigung vorhanden ist. Beide sind komplementär: Coral (Inferenz) + VAAPI/QSV/NVDEC (Decodierung) = optimale Kombination. Die Integration sollte beide Aspekte separat anbieten, nicht als exklusive Wahl.

Und hier brauche ich dich :slight_smile: : Du hast bereits ein laufendes Coral. Wenn du mir den Typ (USB? M.2?) teilen kannst, deine tatsächliche Inferenzgeschwindigkeit und den Teil deiner docker-compose, der das Gerät bei dir mountet, wäre das eine Testbasis, die ich nicht zur Hand habe. Das wäre ein echter Beitrag zum Projekt.

2. Das YAML: Meine Position (und ich denke, wir sind uns im Kern einig)

Hier werde ich deine Anforderung etwas umformulieren, weil ich glaube, dass das wahre Ziel nicht „die Bearbeitung des YAMLs erleichtern“ ist, sondern „das YAML nicht bearbeiten zu müssen“. :grin:

Wenn Gladys sich damit begnügt, einen schöneren YAML-Editor als den von Frigate anzubieten, bringen wir nichts: Es ist besser, Frigate direkt zu verwenden. Der Wert von Gladys (und ihre Philosophie) besteht darin, Wissen in Konfiguration umzuwandeln. Die breite Masse sollte nie YAML sehen.

Daher werden wir nicht alles unterstützen, aber was wir unterstützen, werden wir gut machen. Daneben ist es durchaus möglich, einen Äquivalent zur automatischen Erstellung von GitHub-Issues wie bei Tuya einzurichten. Dies wird normalerweise die Grundlage für eine einfache Konfiguration in Gladys schaffen.

Aber das Ziel ist es dennoch, Dinge manuell im YAML für erfahrene Benutzer zu ermöglichen. Allerdings denke ich nicht, dass wir dies direkt in der Oberfläche erwähnen. Schließlich wird @pierre-gilles entscheiden :wink:

Beantwortet das deine Fragen? Und wenn du weitere knifflige Fälle mit Frigate hattest (Reolink-Konfiguration, Coral-Fälle, Performance-Fallen…), sind sie willkommen: Jede hier dokumentierte Falle ist eine Falle, die die Integration allen erspart. Das ist ein bisschen der ganze Sinn, darüber zu sprechen, bevor man codiert. :slight_smile:

Danke für deine Antworten, das ist sehr klar!
Aber ich muss zugeben, dass ich, auch wenn ich es geschafft habe, alles zum Laufen zu bringen, immer noch Schwierigkeiten habe, meine Kenntnisse und die passenden Konzepte zu ordnen.

Ich habe einen Coral USB und schaue mir die Docker-Compose-Datei an, sobald ich an meinem PC bin.
Willst du meine gesamte config.yaml-Datei sehen?

Ich habe deine Idee bezüglich der Konfiguration verstanden und teile deine Vision der Implementierung voll und ganz :+1:

Ja, gerne beides, wenn möglich, aber vergiss nicht, deine persönlichen Daten aus der Konfiguration zu entfernen, vor allem :wink:

Mein docker compose:

  GNU nano 6.2                                                                                        docker-compose.yml                                                                                                 
services:
  frigate:
    container_name: frigate
    privileged: true
    restart: unless-stopped
    image: ghcr.io/blakeblackshear/frigate:0.17.0
    shm_size: "512mb"
    devices:
      - /dev/bus/usb:/dev/bus/usb
      - /dev/dri/renderD128:/dev/dri/renderD128
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - ./config:/config
      - ./storage:/media/frigate
      - type: tmpfs
        target: /tmp/cache
        tmpfs:
          size: 1000000000
    ports:
      - "8971:8971"
      - "8554:8554"
      - "8555:8555"
      - "8555:8555/udp"
      - "1984:1984"
    environment:
      FRIGATE_RTSP_PASSWORD: "mon-password"
      PLUS_API_KEY: "ma-clé"

Meine config.yaml:

auth:
  enabled: true

mqtt:
  host: 192.168.100.150
  port: 1883

ffmpeg:
  hwaccel_args: preset-vaapi

detect:
  enabled: true
  width: 1280
  height: 720
  fps: 5

record:
  enabled: true
  continuous:
    days: 2
  alerts:
    retain:
      days: 7
      mode: all
  detections:
    retain:
      days: 7
      mode: all

snapshots:
  enabled: true

detectors:
  coral:
    type: edgetpu
    device: usb

model:
  path: plus://ref
  width: 320
  height: 320
  model_type: yolo-generic
  input_tensor: nhwc
  input_pixel_format: rgb

semantic_search:
  enabled: true
  model_size: small 

face_recognition:
  enabled: true
  model_size: small
  min_area: 200

lpr:
  enabled: true

objects:
  track: [person, car, dog, cat]
  filters:
    person:
      threshold: 0.80
      min_area: 2500
    car:
      threshold: 0.85

go2rtc:
  streams:
    CAM1:
      - ffmpeg:http://192.168.100.201/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=admin&password=mon-password#video=copy#audio=copy#audio=opus
    CAM1_SUB:
      - ffmpeg:http://192.168.100.201/flv?port=1935&app=bcs&stream=channel0_ext.bcs&user=admin&password=mon-password
    CAM2:
      - ffmpeg:http://192.168.100.202/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=admin&password=mon-password#video=copy#audio=copy#audio=opus
    CAM2_SUB:
      - ffmpeg:http://192.168.100.202/flv?port=1935&app=bcs&stream=channel0_ext.bcs&user=admin&password=mon-password
    CAM3:
      - ffmpeg:http://192.168.100.203/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=admin&password=mon-password#video=copy#audio=copy#audio=opus
    CAM3_SUB:
      - ffmpeg:http://192.168.100.203/flv?port=1935&app=bcs&stream=channel0_ext.bcs&user=admin&password=mon-password

cameras:
  CAM1:
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:8554/CAM1
          roles: [record]
        - path: rtsp://127.0.0.1:8554/CAM1_SUB
          roles: [detect]
    face_recognition:
      enabled: true

  CAM2:
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:8554/CAM2
          roles: [record]
        - path: rtsp://127.0.0.1:8554/CAM2_SUB
          roles: [detect]
    lpr:
      enabled: true
      min_area: 100
    face_recognition:
      enabled: true

  CAM3: # Garage / Chatière
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:8554/CAM3
          roles: [record]
        - path: rtsp://127.0.0.1:8554/CAM3_SUB
          roles: [detect]
    detect:
      enabled: true
    objects:
      track: [cat, person]
      filters:
        cat:
          min_area: 400
          threshold: 0.6

    zones:
      zone_chatiere:
        coordinates: 0.296,0.144,0.835,0.156,0.814,0.639,0.285,0.621
        loitering_time: 0
        objects: cat
        inertia: 3
 
version: 0.17-0

Du hast alles!

Ich bin dabei für die Tests … aber ich habe keine Kamera :joy:

Tatsächlich gibt es (unter anderem) eine Kamera, die ich gerne hätte: eufy Security Solar Wall Light Cam S120.
Kein RTSP und kein ONVIF.
Falls du denkst, dass wir sie integrieren können, kann ich eine für die Tests besorgen.

Oki, dann suchen wir vorher die Literatur :sweat_smile: :wink:

1er jet:





Derzeit läuft es mit 2 Kameras auf dem CPU des Beelink, zusätzlich zu 2 Gladys + 1 HA:
image

Jetzt geht es zum GPU, der vom aktuellen System überhaupt nicht genutzt wird!

Hallo,

Sehr nett diese Funktion :slight_smile:
Da ich bereits einen Frigate auf einer anderen Maschine installiert habe, denken Sie, dass es möglich ist, einen externen Frigate zu verwenden? :slight_smile:

Danke

Hallo @prohand,

Ich denke, dass es, wenn alles in dieser Form bestätigt wird, durchaus möglich sein wird, wie bei Zigbee2mqtt vorzugehen und einen externen Frigate auszuwählen!!

Wir werden einfach ein Entdeckungs-Register hinzufügen, denke ich, alles sollte sich dann von selbst wieder aufbauen. Allerdings werden wir die Geräte und Container-Updates wahrscheinlich nicht steuern können. Nun, zumindest sehe ich es im Moment so ^^

Ja danke.
Ich kann Tests durchführen, wenn es implementiert ist :wink:

Eine kleine Nachricht, nur um mich auszudrücken … Ich finde es verrückt, Frigate erst jetzt zu entdecken
Es ist unglaublich, was dieser Tool für Möglichkeiten bietet!! Und das mit einem Mini-PC, der bereits nicht ganz unbedeutende Dinge laufen lässt …
Ich bin sprachlos, wenn ich daran denke, dass ich damals Netatmo zu einem Wahnsinnspreis (negativ) gekauft habe und Frigate die Arbeit 10 Mal besser mit Kameras macht, die 5 bis 6 Mal günstiger sind …
Präzise Erkennung, Definition von Multi-Zonen nach Erkennungstyp, Einstellungen, Geschwindigkeitsberechnung :scream:, Gesichtserkennung, Kennzeichenerkennung…


Ich schäme mich, dass ich all diese Themen zu Frigate seit einem Jahr nicht gesehen habe!!

Wir haben gute Fortschritte gemacht, ein Testbild ist hier verfügbar für diejenigen, die es sehen möchten: docker pull terdious/gladys:Frigate-test

Achtung für die Besitzer einer Frigate-Instanz, normalerweise wird die Portverwaltung vollständig verwaltet. Aber man kann nie wissen, ich habe die Parallelisierung noch nicht getestet. Daher empfehle ich, entweder die Produktionsinstanz während der Tests zu deaktivieren oder dies auf einer separaten Maschine durchzuführen.

Auch einige Kameras unterstützen nur 1 Zugriff gleichzeitig, daher ist es vorerst ratsam, dies mit der deaktivierten Produktionsinstanz von Frigate zu testen.

Google Coral ist noch nicht implementiert. Sollte aber sehr bald kommen :face_with_peeking_eye: :wink:

Das Ziel ist es, die Verständlichkeit und die Einfachheit der Implementierung des Systems zu testen. Zu prüfen, ob die Erklärungen in der Oberfläche ausreichend sind (außerhalb der Dokumentation, die bei Bedarf weiter vertieft wird). Und natürlich, dass es für Besitzer von Tapo / Reolink funktioniert ^^

Was implementiert ist:

  • Frigate-Integration,
  • Container-Deployment
  • Hinzufügen eines Geräts
  • Auswahl der gewünschten Anwesenheitserkennung
  • Automatisierung der Nutzung von CPU oder GPU je nach dem, was das System anbietet (der optionale, änderbare Teil wird mit der Integration von Google Coral kommen
  • Zugriff auf die Frigate-Webseite
  • Hochladen des Bildes und des Videos
  • Hochladen der Anwesenheitserkennung (1 pro ausgewählter Erkennungstyp)
  • Vorbereitung der Erstellung eines GitHub-Issues für nicht unterstützte Kameras

Ich versuche morgen einen Test zu machen :clap:

Wird das mit Action LSC-Kameras ohne RTSP und Imou-Kameras mit RTSP funktionieren?

Das wird die Gelegenheit sein, all das zu testen ^^ Danach sind es bei den LSC-Kameras Tuya, oder? Ich bin gerade dabei, auf dieser Seite mit @GBoulvin zu entwickeln! Aber wir können hoffentlich beide testen!!