William Zhang2026-09-22

NVR-System auf Basis von Frigate auf dem reComputer RK3576

Stellen Sie das Frigate-NVR auf dem reComputer RK3576 mit nur einem Docker-Befehl bereit und aktivieren Sie die hardwarebeschleunigte Decodierung sowie die RKNN-Inferenz.

NVRCVEdge AIGithub

Schneller Aufbau eines On-Device-NVR-Projekts auf Basis von RK3576 / Docker / RKNN / Frigate.

Frigate ist eine Open-Source-NVR mit Schwerpunkt auf lokaler, echtzeitbasierter KI-Objekterkennung. Die gesamte Inferenz läuft auf Ihrer eigenen Hardware – Kamerastreams werden niemals auf einen Cloud-Server hochgeladen – was sowohl die Privatsphäre schützt als auch teure monatliche Cloud-AI-Abonnementgebühren vermeidet. Frigate unterstützt benutzerdefinierte Erkennungszonen und Maskierungszonen und integriert sich nahtlos in Home Assistant, um NVR-Feeds in Smart-Home-Automatisierungen einzubinden.

Diese Anleitung zeigt, wie Sie Frigate auf dem reComputer RK3576 mit Docker Compose bereitstellen und den im RK3576 integrierten Rockchip-MPP-Stack (Hardware-Decodierung) + RGA (2D-Beschleunigung) + RKNN (NPU-Inferenz) für Echtzeit-Videoanalysen mit geringer CPU-Auslastung nutzen.

Erste Schritte

In dieser Anleitung folgen wir dem offiziellen Bereitstellungsablauf und zeigen, wie Sie eine Frigate-Docker-Umgebung konfigurieren, die lokale KI-Erkennung an RTSP-Kamerastreams auf dem reComputer RK3576 durchführt.

Voraussetzungen gemäß offizieller Dokumentation

Frigate empfiehlt offiziell:

  • Ein Debian-basiertes Betriebssystem als bevorzugter Host;
  • VMs werden nicht empfohlen (Proxmox, ESXi, Virtualbox) — einige Proxmox-Konfigurationen können funktionieren, erhöhen jedoch die Komplexität für Coral/GPU-Passthrough;
  • Windows wird offiziell nicht unterstützt (WSL / Virtualbox können möglicherweise funktionieren, aber GPU/Coral-Passthrough ist schwierig).

Für Rockchip-Plattformen überprüfen Sie die Version Ihres Systemabbilds:

bash
$ uname -r
5.10.xxx-rockchip

$ ls /dev/dri
by-path  card0  card1  renderD128  renderD129

$ sudo cat /sys/kernel/debug/rknpu/version
RKNPU driver: v0.9.2

Berechnung des benötigten Shared Memory

Frigate verwendet Shared Memory, um Videoframes zu verarbeiten. Die von Docker bereitgestellte Standard-shm-size beträgt 64 MB. Für ein Erkennungsszenario mit zwei 720p-Kameras ist die Standardgröße von 128 MB Shared Memory ausreichend. Wählen Sie die Shared-Memory-Allokation basierend auf Ihrer tatsächlichen Situation, um die Ressourcen optimal zu nutzen.

Wir empfehlen die Verwendung des offiziellen Online-Rechners: https://docs.frigate.video/frigate/installation#calculating-required-shm-size

Download-Link abrufen

Besuchen Sie die offizielle Website https://docs.frigate.video/frigate/installation#docker und wählen Sie die folgenden Optionen, um die Installationsanweisungen zu erhalten.

Füllen Sie den Abschnitt Storage Paths entsprechend Ihren tatsächlichen Anforderungen aus (Sie können einige leer lassen, falls nicht erforderlich). Unter Other Options tragen Sie die oben berechnete Speichergröße ein; Sie können auch manuell ein Passwort festlegen (optional).

Kopieren Sie anschließend die Installationsanweisungen:

yaml
services:
  frigate:
    container_name: frigate
    privileged: true # This may not be necessary for all setups
    restart: unless-stopped
    stop_grace_period: 30s # Allow enough time to shut down the various services
    image: ghcr.io/blakeblackshear/frigate:stable-rk
    shm_size: "512mb" # Update for your cameras based on SHM calculation
    security_opt:
      - apparmor=unconfined
      - systempaths=unconfined
    devices:
      - /dev/dma_heap # Rockchip DMA heap
      - /dev/rga # Rockchip RGA
      - /dev/mpp_service # Rockchip MPP service
      - /dev/dri # Intel/AMD GPU hardware acceleration
    volumes:
      - /etc/localtime:/etc/localtime:ro # Sync host time
      - /path/to/your/config:/config # Config file directory
      - /path/to/your/storage:/media/frigate # Recording storage directory
      - type: tmpfs # 1GB in-memory filesystem for recording segment storage
        target: /tmp/cache
        tmpfs:
          size: 1000000000
      - /sys/:/sys/:ro # Rockchip system info
    ports:
      - "8554:8554" # Access RTSP feeds from go2rtc
      - "8971:8971" # Authenticated UI and API access (default HTTPS)
      - "8555:8555" # WebRTC over TCP
      - "8555:8555/udp" # WebRTC over UDP
    environment:
      TZ: "Asia/Shanghai" # Timezone

Oder Sie können die getestete und verifizierte Konfiguration direkt von GitHub beziehen: https://github.com/doublelf/RK_friigate_dockeryml

yaml
services:
  frigate:
    container_name: frigate
    privileged: true # Privilegierten Modus verwenden
    restart: unless-stopped
    stop_grace_period: 30s # Ausreichend Zeit zum Herunterfahren der Dienste einräumen
    image: docker.cnb.cool/frigate-cn/frigate:stable-rk # Hier handelt es sich um eine inländische Mirror-URL; die Original-URL ist ghcr.io/blakeblackshear/frigate:stable-rk
    shm_size: "512mb" # Aktualisieren Sie diesen Wert für Ihre Kameras gemäß der obigen Berechnung
    devices:
      - /dev/dri:/dev/dri # Für GPU-Hardwarebeschleunigung
      - /dev/dma_heap # RockChip DMA-Heap
      - /dev/rga # RockChip RGA
      - /dev/mpp_service # RockChip MPP-Dienst
    security_opt:
      - apparmor=unconfined
      - systempaths=unconfined
    volumes:
      - /etc/localtime:/etc/localtime:ro # Host-Zeit synchronisieren
      - /home/seeed/frigate/config:/config # "/home/seeed/frigate/config" ist der Pfad auf Ihrem Host, an dem Sie Konfigurationsdateien speichern möchten
      - /home/seeed/frigate/video:/media/frigate # "/home/seeed/frigate/video" ist der Pfad auf Ihrem Host, an dem Sie Überwachungsaufnahmen speichern möchten
      - type: tmpfs # 1 GB RAM als temporären Speicher für Aufnahmesegmente verwenden
        target: /tmp/cache
        tmpfs:
          size: 1000000000
      - /sys/:/sys/:ro # RockChip-Systeminformationen
    ports:
      - "8971:8971" # Standardport des Frigate-Dienstes, standardmäßig HTTPS
      - "8554:8554" # RTSP-Videostream
      - "8555:8555/tcp" # WebRTC über TCP
      - "8555:8555/udp" # WebRTC über UDP
    environment:
      FRIGATE_RTSP_PASSWORD: "password" # RTSP-Passwort; bitte auf das gewünschte Passwort ändern
      TZ: "Asia/Shanghai" # Auf die Zeitzone China +8 einstellen
      HF_ENDPOINT: "https://huggingface.mirror.frigate-cn.video" # Von uns bereitgestellter Huggingface-Inlandsmirror für beschleunigte Downloads einiger von Frigate benötigter Modelle
      GITHUB_ENDPOINT: "https://github.mirror.frigate-cn.video" # Von uns bereitgestellter GitHub-Inlandsmirror für beschleunigte Downloads einiger von Frigate benötigter Modelle
      TF_KERAS_MOBILENET_V2_WEIGHTS_URL: https://cnb.cool/frigate-cn/mirrors/storage.googleapis/-/git/raw/main/tensorflow/keras-applications/mobilenet_v2/mobilenet_v2_weights_tf_dim_ordering_tf_kernels_0.35_224_no_top.h5 # Vom Klassifikationsmodell benötigte Gewichtungsdatei

Erstellen Sie die Datei docker-compose.yml, fügen Sie den obigen Inhalt ein und führen Sie im Terminal Folgendes aus:

bash
docker compose up -d

Nach Abschluss des Builds ist Frigate lokal eingerichtet. Anschließend können Sie die Konfigurationsdatei ändern und nach dem Start den Betrieb im Backend überprüfen.

Offizielle minimale config.yml

Die folgende config.yml ist eine minimale lauffähige Konfiguration: 1 RTSP-Kamera + MQTT deaktiviert + Standard-Detector (CPU), die standardmäßig nach der Installation von Frigate bereitgestellt wird. Wenn Sie diese Datei nicht haben, müssen Sie sie manuell erstellen.

bash
mkdir -p ~/frigate/config
tee ~/frigate/config/config.yml > /dev/null << 'EOF'

mqtt:
  enabled: False

cameras:
  my_cam:
    ffmpeg:
      inputs:
        - path: rtsp://viewer:{FRIGATE_RTSP_PASSWORD}@<camera-ip>:554/stream
          roles:
            - detect
    detect:
      width: 1280
      height: 720

detect:
  fps: 5
EOF

Ersetzen Sie <camera-ip> durch die tatsächliche IP Ihrer Kamera. Speichern Sie diese Datei unter /path/to/your/config/config.yml (also das in docker-compose gemappte /config).

Diese Konfiguration kann auch so geändert werden, dass mehrere Kameras gleichzeitig laufen. Sie müssen nur weitere Strukturen unter der obigen Konfiguration hinzufügen. Die folgende Konfiguration zeigt den Start zweier Kameras mit unterschiedlichen Detailkonfigurationen:

yaml
mqtt:
  enabled: false

face_recognition:
  enabled: true

go2rtc:
  streams:
    usb_camera:
      - ffmpeg:device?video=0&video_size=640x480#video=h264

cameras:
  usb_camera:
    ffmpeg:
      inputs:
        - path: rtsp://127.0.0.1:8554/usb_camera
          input_args: preset-rtsp-restream
          roles:
            - detect
            - record
    detect:
      width: 640
      height: 480
      enabled: false  # Erkennung zunächst deaktivieren, um zuerst den Videostream zu testen

    record:
      enabled: true
      continuous:
        days: 0 # Bei 0 werden standardmäßig keine Überwachungsvideos ohne angegebenen Typ aufgenommen
      alerts: # Hier wird angegeben, dass nur Alarmvideos aufgenommen werden; die obige Einstellung wird ignoriert
        retain:
          days: 30
          mode: motion

    zones:
      zone_b32f13ac:
        coordinates: 0.867,0.093,0.417,0.115,0.437,0.859,0.974,0.85
        loitering_time: 0
        friendly_name: Zone 1

  video_test:  # Geben Sie dieser Testkamera einen Namen
    ffmpeg:
      inputs:
        - path: /home/seeed/frigate/test.mp4  # Pfad zu Ihrer Videodatei
          input_args: -re -stream_loop -1 -fflags +genpts
          roles:
            - detect
            - record
    detect:
      enabled: true
    record:
      enabled: false  # Aufnahme während des Tests wird empfohlen zu deaktivieren
    snapshots:
      enabled: false  # Snapshots während des Tests wird empfohlen zu deaktivieren

version: 0.17-0

cameras, video_test jeweils eingerückt starten, jeder stellt eine Kamerakonfiguration dar. ffmpeg gibt die Gesamtkonfiguration der Kamera an, einschließlich Videodateipfad und Anwendungsrollen. detect steht für die Objekterkennungsfunktion, record für die Aufnahmefunktion und snapshots für die Snapshot-Funktion.

Start und Überprüfung

Folgen Sie dem Ablauf:

bash
cd /path/to/your/frigate
sudo docker compose up -d

# Start-Logs anzeigen
sudo docker compose logs -f frigate

Wenn die Logs INFO : Frigate started successfully. enthalten oder die Web-UI auf 0.0.0.0:8971 lauscht, ist der Start erfolgreich.

Suchen Sie in den Logs nach den Schlüsselwörtern, um Konto und Passwort zu erhalten:

bash
docker logs frigate 2>&1 | grep -Ei 'rtsp://|rtsps://|password|passwd|user|username|@'

Möglicherweise sehen Sie etwas wie rtsp://admin:password@192.168.1.100:554/stream.

bash
# Container-Status überprüfen
sudo docker compose ps
# Erwartet wird, dass der Frigate-Dienst den Status running / healthy hat
bash
# Browser-Zugriff
https://<your-host-ip>:8971

Melden Sie sich mit Konto und Passwort an.

Nach erfolgreicher Anmeldung sehen Sie die gesamte Ansicht sowie die in der vorherigen Konfigurationsdatei konfigurierten Kamerainformationen:

Wählen Sie eine davon aus und klicken Sie sie an. Klicken Sie dann oben rechts auf die Debug-Oberfläche, um alle Funktionen im Bild zu sehen. Oben rechts befinden sich die Funktionen, die in der Konfigurationsdatei eingestellt werden können, um zu bestimmen, ob sie enthalten sind oder im Voraus gestartet werden sollen. Links befinden sich die integrierten Funktionen, mit denen später Grenzen usw. entworfen werden können: