RK3576 Frigate: Objekterkennung mit RKNN

Zuletzt aktualisiert:

Einführung

Im vorherigen Tutorial haben wir Frigate NVR auf dem reComputer RK3576 installiert und die Weboberfläche geöffnet. Jetzt binden wir eine Videoquelle ein und aktivieren die RKNN-NPU-Objekterkennung, um Personen, Fahrräder und Autos zu erkennen.

Du kannst eine externe RTSP-IP-Kamera oder eine vorhandene lokale Videodatei verwenden. Ein bestimmtes Beispielvideo ist nicht erforderlich. Sobald die Objekterkennung funktioniert, kannst du mit einer kompatiblen RTSP-Kamera zusätzlich die RKMPP-Hardware-Videodekodierung testen.

RKNN und RKMPP: RKNN beschleunigt die KI-Modellinferenz auf der NPU des RK3576. RKMPP beschleunigt die Videodekodierung über die Rockchip-Multimediahardware. Es sind getrennte Beschleunigungspfade.

Die Beispiele folgen der offiziellen Frigate-Konfiguration. Prüfe die Erkennung auf deinem Gerät.

Voraussetzungen

Schließe zuerst Erste Schritte mit Frigate NVR auf dem reComputer RK3576 ab und prüfe, ob du dich unter https://<RK3576_IP>:8971 anmelden kannst.

Verwende Linux mit einem kompatiblen Rockchip-BSP-Kernel und dem RKNPU-Treiber für die RKNN-Inferenz. Für RKMPP ist außerdem der Rockchip-Videodekodertreiber einschließlich rkvdec2 erforderlich.

Diese Anleitung verwendet das Projektverzeichnis ~/frigate-rk aus Teil 1. In Docker Compose ist ./config nach /config und ./storage nach /media/frigate eingebunden. Hardwarevoraussetzungen, Docker-Installation und die erste Administratoreinrichtung werden nicht wiederholt.

Schritt 1: Vorhandene Frigate-Konfiguration sichern

Verbinde dich per SSH mit dem RK3576 und sichere die Konfiguration vor dem Bearbeiten:

bash
cd ~/frigate-rk
sudo docker compose ps
FRIGATE_CONFIG_DIR="$HOME/frigate-rk/config"
sudo ls -lah "$FRIGATE_CONFIG_DIR"

Frigate unterstützt config.yml und config.yaml. Sind beide vorhanden, hat config.yml Vorrang. Führe nach dem Auflisten des Verzeichnisses den folgenden Block aus, um die vorhandene Datei auszuwählen und zu sichern. Die weiteren Schritte verwenden denselben Pfad.

bash
FRIGATE_CONFIG_FILE=
if sudo test -f "$FRIGATE_CONFIG_DIR/config.yml"; then
  FRIGATE_CONFIG_FILE="$FRIGATE_CONFIG_DIR/config.yml"
elif sudo test -f "$FRIGATE_CONFIG_DIR/config.yaml"; then
  FRIGATE_CONFIG_FILE="$FRIGATE_CONFIG_DIR/config.yaml"
fi

if [ -n "$FRIGATE_CONFIG_FILE" ]; then
  sudo cp -- "$FRIGATE_CONFIG_FILE" "${FRIGATE_CONFIG_FILE}.before-rknn.bak"
  printf 'Using configuration: %s\n' "$FRIGATE_CONFIG_FILE"
else
  printf '%s\n' 'No config.yml or config.yaml found. Check the /config mount before continuing.' >&2
fi

Wird keine der Dateien gefunden, prüfe die Einbindungen des Containers:

bash
sudo docker inspect frigate --format '{{range .Mounts}}{{println .Source "->" .Destination}}{{end}}'

Suche das Host-Verzeichnis, das nach /config eingebunden ist, setze FRIGATE_CONFIG_DIR auf dieses Verzeichnis und wiederhole die obige Auflistung und Auswahl. Wenn dein Deployment einen anderen Konfigurationspfad vorgibt, suche diese Datei, bevor du fortfährst.

Passe die Befehle an, falls du ein anderes Verzeichnis verwendest. Behalte beim Zusammenführen der Beispiele die vorhandene Authentifizierung und eigene Kameraeinstellungen bei. Lege YAML-Schlüssel auf oberster Ebene nicht doppelt an, etwa cameras:, detectors: oder model:.

Schritt 2: Videoquelle auswählen

Wähle Option A oder Option B, nicht beide. Beide verwenden denselben RKNN-Detektor aus Schritt 3.

Option A: Externe RTSP-IP-Kamera verbinden

Diese Option eignet sich für einen echten NVR-Einsatz und spätere RKMPP-Dekodierungstests.

  1. Verbinde die IP-Kamera mit einem vom RK3576 erreichbaren Netzwerk.

  2. Aktiviere RTSP in den Kameraeinstellungen und notiere RTSP-URL und Zugangsdaten, zum Beispiel:

    text
    rtsp://USERNAME:PASSWORD@CAMERA_IP:554/STREAM_PATH

    Ersetze alle Platzhalter durch die vom Kamerahersteller vorgegebene URL.

  3. Prüfe den RTSP-Stream bei Bedarf auf dem RK3576 mit ffprobe aus dem Paket ffmpeg:

    bash
    ffprobe -v error -rtsp_transport tcp \
  -show_entries stream=codec_name,width,height \
  -of default=noprint_wrappers=1 \
  'rtsp://USERNAME:PASSWORD@CAMERA_IP:554/STREAM_PATH'

    Ein funktionierender Stream liefert Videocodec und Auflösung zurück. Veröffentliche keine echten Zugangsdaten.

    Nutze für die Erkennung nach Möglichkeit den 720p-Substream der Kamera. Ein 4K-Hauptstream erhöht nur die Dekodierlast; die Modelleingabe bleibt 320×320.

USB-Kameras: Eine USB-Webcam ist keine RTSP-IP-Kamera. Stelle das Video zunächst über einen kompatiblen Eingang oder eine RTSP-Bridge für Frigate bereit. Setze /dev/video0 nicht direkt in die RTSP-Beispiel-URL ein.

Option B: Vorhandene lokale Videodatei verwenden

Wenn du keine IP-Kamera hast, verwende eine eigene Videodatei, etwa eine MP4 mit Personen oder Fahrzeugen. Du musst kein bestimmtes Beispielvideo herunterladen.

Verwende eine 1280×720, 15 fps, H.264-MP4, in der Personen oder Fahrzeuge deutlich zu erkennen sind. Ist dein Clip größer, konvertiere ihn zuerst:

bash
ffmpeg -i input.mp4 -vf "fps=15,scale=1280:720" \
  -c:v libx264 -pix_fmt yuv420p -crf 23 -an test.mp4

Kopiere anschließend die konvertierte test.mp4 nach storage/test.mp4 (ersetze den Pfad im folgenden Befehl).

Kopiere die Datei in den für Frigate eingebundenen Ordner:

bash
cd ~/frigate-rk
# Replace /path/to/your-video.mp4 with your existing file path.
cp /path/to/your-video.mp4 storage/test.mp4

Liegt die Datei auf deinem Computer, kannst du sie stattdessen per SCP oder SFTP nach ~/frigate-rk/storage/test.mp4 übertragen. Prüfe, ob der Container sie sieht:

bash
sudo docker exec frigate ls -lh /media/frigate/test.mp4

Wir verwenden Frigates Manual-Dummy-Camera-Methode, bei der FFmpeg eine lokale Datei wiederholt abspielt.

Schritt 3: RKNN-Detektor und Kamera konfigurieren

Öffne die erkannte Konfigurationsdatei im selben SSH-Terminal wie in Schritt 1. Nach einer erneuten Verbindung oder bei leerer Variable musst du zuerst Schritt 1 wiederholen:

bash
if [ -n "${FRIGATE_CONFIG_FILE:-}" ] && sudo test -f "$FRIGATE_CONFIG_FILE"; then
  sudo nano "$FRIGATE_CONFIG_FILE"
else
  printf '%s\n' 'Repeat Step 1 to locate the existing configuration before editing.' >&2
fi

Beide Optionen verwenden diese RKNN-Detektorkonfiguration:

yaml
detectors:
  rknn_0:
    type: rknn
    num_cores: 0

model:
  path: frigate-fp16-yolov9-t
  model_type: yolo-generic
  width: 320
  height: 320
  input_tensor: nhwc
  labelmap_path: /labelmap/coco-80.txt

Dieses Beispiel verwendet das RKNN-Erkennungsmodell frigate-fp16-yolov9-t. Die 320 × 320 sind die Eingabegröße des Modells, nicht die Videoauflösung der Kamera. Beim ersten Start wird das Modell automatisch heruntergeladen und anschließend zwischengespeichert; der erste Download benötigt Netzwerkzugriff.

Wähle für eine Demonstration mit einer Quelle eines der vollständigen Beispiele. Müssen bestehende Einstellungen erhalten bleiben, führe die betreffenden Abschnitte zusammen, statt die ganze Datei zu ersetzen.

Vollständige Konfiguration – Option A: RTSP-Kamera

yaml
mqtt:
  enabled: false

detectors:
  rknn_0:
    type: rknn
    num_cores: 0

model:
  path: frigate-fp16-yolov9-t
  model_type: yolo-generic
  width: 320
  height: 320
  input_tensor: nhwc
  labelmap_path: /labelmap/coco-80.txt

cameras:
  front_door:
    enabled: true
    ffmpeg:
      inputs:
        - path: rtsp://USERNAME:PASSWORD@CAMERA_IP:554/STREAM_PATH
          roles:
            - detect
    detect:
      enabled: true
      fps: 5
    objects:
      track:
        - person
        - bicycle
        - car
    record:
      enabled: false
    snapshots:
      enabled: false

Wichtig: Ersetze die RTSP-URL vor dem Neustart. Aufzeichnung und Schnappschüsse sind zunächst deaktiviert, um die Objekterkennung gezielt zu testen.

Vollständige Konfiguration – Option B: Lokale MP4

yaml
mqtt:
  enabled: false

detectors:
  rknn_0:
    type: rknn
    num_cores: 0

model:
  path: frigate-fp16-yolov9-t
  model_type: yolo-generic
  width: 320
  height: 320
  input_tensor: nhwc
  labelmap_path: /labelmap/coco-80.txt

cameras:
  demo_video:
    enabled: true
    ffmpeg:
      # Local clips may require software decoding.
      hwaccel_args: ""
      inputs:
        - path: /media/frigate/test.mp4
          input_args: -re -stream_loop -1 -fflags +genpts
          roles:
            - detect
    detect:
      enabled: true
      fps: 5
    objects:
      track:
        - person
        - bicycle
        - car
    record:
      enabled: false
    snapshots:
      enabled: false

-re liest die Datei mit ihrer ursprünglichen Geschwindigkeit, -stream_loop -1 wiederholt die Wiedergabe und -fflags +genpts erzeugt bei Bedarf Zeitstempel. Falls die lokale Datei nicht mit dem Hardwaredekoder funktioniert, deaktiviert hwaccel_args: "" die Videohardwarebeschleunigung für diese Dummy-Kamera. Die RKNN-Objekterkennung kann weiterhin auf der NPU laufen.

Schritt 4: Frigate neu starten und RKNN-Initialisierung prüfen

Speichere die in Schritt 1 ausgewählte Datei (config.yml oder config.yaml) und starte den vorhandenen Frigate-Container neu:

bash
cd ~/frigate-rk
sudo docker compose restart frigate
sudo docker compose ps

Prüfe relevante Logs, ohne den gesamten Verlauf auszugeben:

bash
sudo docker logs --since 5m frigate 2>&1 | \
  grep -iE 'rknn|model|detector|ffmpeg|error|failed' | tail -n 100

Warte beim ersten Start, bis das Modell heruntergeladen und initialisiert wurde. Sein Cache wird hier angelegt:

text
~/frigate-rk/config/model_cache/rknn_cache/

Den Cache kannst du so prüfen:

bash
sudo ls -lh ~/frigate-rk/config/model_cache/rknn_cache/

Fahre mit der Laufzeitprüfung in Schritt 5 fort.

Schritt 5: Erkennungsergebnisse und NPU-Nutzung prüfen

  1. Öffne https://<RK3576_IP>:8971 und melde dich an.

  2. Suche die konfigurierte Kamera: front_door für Option A oder demo_video für Option B.

  3. Öffne Debug view und aktiviere Debugging Bounding Boxes. Um erkannte Objekte erscheinen Rahmen mit den Bezeichnungen person, bicycle oder car.

    Debug view in Frigate mit Erkennungsrahmen um erkannte Fahrzeuge

    Wenn keine Rahmen erscheinen, prüfe, ob der Clip ein verfolgtes Objekt enthält, Debugging Bounding Boxes aktiviert ist und im Log Successfully loaded RKNN model steht.

  4. Öffne die Frigate-Seite System und prüfe die Inferenzzeit des Detektors sowie die Erkennungs-FPS, soweit deine Version sie anzeigt.

  5. Prüfe auf dem RK3576 die NPU-Auslastung, während relevante Bewegung im Video zu sehen ist:

    bash
    sudo cat /sys/kernel/debug/rknpu/load

    Du kannst die Auslastung auch wiederholt überwachen:

    bash
    watch -n 1 'sudo cat /sys/kernel/debug/rknpu/load'

Die NPU-Auslastung schwankt je nach Bewegung. Prüfe die Erkennungen in der Überlagerung und in den Frigate-Metriken.

Schritt 6 (optional): RKMPP-Hardware-Videodekodierung aktivieren

Nutze diesen Schritt hauptsächlich mit Option A, RTSP-Kamera, nachdem die RKNN-Erkennung funktioniert. RKMPP beschleunigt die Dekodierung kompatibler Videos und ist nicht der Objektdetektor.

Ergänze in der vorhandenen Kamera front_door unter ffmpeg: die Einstellung hwaccel_args: preset-rkmpp:

yaml
cameras:
  front_door:
    ffmpeg:
      hwaccel_args: preset-rkmpp
      inputs:
        - path: rtsp://USERNAME:PASSWORD@CAMERA_IP:554/STREAM_PATH
          roles:
            - detect

Dies ist ein Teilbeispiel. Behalte die übrigen Kamera-, RKNN-Modell- und Detektoreinstellungen aus Schritt 3 bei.

Starte Frigate neu und prüfe die FFmpeg-Logs:

bash
sudo docker compose restart frigate
sudo docker logs --since 5m frigate 2>&1 | \
  grep -iE 'ffmpeg|rkmpp|rkvdec|error|failed' | tail -n 100

Prüfe, ob Kamerastream und KI-Erkennung weiter funktionieren und FFmpeg nicht wiederholt mit Hardwarekontextfehlern abstürzt. Sind auf dem Host passende Werkzeuge vorhanden, kontrolliere auch den aktiven Videodekoder. Vergleiche die CPU-Auslastung beim gleichen Stream und gleicher Auflösung vor und nach dem Aktivieren von RKMPP.

Lasse die Hardwaredekodierung bei der lokalen MP4-Dummy-Kamera für die erste RKNN-Prüfung deaktiviert.