William Zhang2026-09-22

Système NVR basé sur Frigate sur le reComputer RK3576

Déployez Frigate NVR sur le reComputer RK3576 en une seule commande Docker, en activant le décodage accéléré matériellement et l'inférence RKNN.

NVRCVEdge AIGithub

Construisez rapidement un projet NVR embarqué basé sur RK3576 / Docker / RKNN / Frigate.

Frigate est un NVR open source axé sur la détection d'objets par IA en local et en temps réel. Toute l'inférence s'exécute sur votre propre matériel — les flux caméra ne sont jamais téléchargés sur un serveur cloud — ce qui protège à la fois la vie privée et évite les frais d'abonnement mensuels coûteux à une IA cloud. Frigate prend en charge des zones de détection personnalisées et des zones de masquage, et s'intègre de manière transparente à Home Assistant pour intégrer les flux NVR dans les automatisations de la maison intelligente.

Ce guide montre comment déployer Frigate sur le reComputer RK3576 avec Docker Compose et exploiter la pile intégrée au RK3576 combinant Rockchip MPP (décodage matériel) + RGA (accélération 2D) + RKNN (inférence NPU) pour une analyse vidéo en temps réel à faible charge CPU.

Premiers pas

Dans ce guide, nous suivons le flux de déploiement officiel et montrons comment configurer un environnement Docker Frigate qui effectue la détection IA locale sur les flux RTSP des caméras sur le reComputer RK3576.

Prérequis selon la documentation officielle

Frigate recommande officiellement :

  • Un système d'exploitation basé sur Debian comme meilleur hôte ;
  • Les machines virtuelles ne sont pas recommandées (Proxmox, ESXi, Virtualbox) — certaines configurations Proxmox peuvent fonctionner, mais elles ajoutent de la complexité au passthrough Coral/GPU ;
  • Windows n'est pas officiellement supporté (WSL / Virtualbox peuvent fonctionner, mais le passthrough GPU/Coral est difficile).

Pour les plateformes Rockchip, vérifiez la version de votre image système :

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

Calcul de la mémoire partagée requise

Frigate utilise la mémoire partagée pour traiter les images vidéo. La valeur shm-size par défaut fournie par Docker est de 64 Mo. Pour un scénario de détection avec deux caméras 720p, la taille de mémoire partagée par défaut de 128 Mo suffit. Choisissez l'allocation de mémoire partagée en fonction de votre situation réelle pour tirer le meilleur parti des ressources.

Nous recommandons d'utiliser le calculateur officiel en ligne : https://docs.frigate.video/frigate/installation#calculating-required-shm-size

Obtenir le lien de téléchargement

Visitez le site officiel https://docs.frigate.video/frigate/installation#docker et sélectionnez les options suivantes pour obtenir les instructions d'installation.

Remplissez la section Storage Paths selon vos besoins réels (vous pouvez en laisser certaines vides si elles ne sont pas nécessaires). Dans Other Options, indiquez la taille mémoire calculée ci-dessus ; vous pouvez aussi définir un mot de passe manuellement (facultatif).

Copiez ensuite les instructions d'installation :

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

Vous pouvez aussi récupérer directement la configuration testée et validée depuis GitHub : https://github.com/doublelf/RK_friigate_dockeryml

yaml
services:
  frigate:
    container_name: frigate
    privileged: true # Utiliser le mode privilégié
    restart: unless-stopped
    stop_grace_period: 30s # Laisser suffisamment de temps pour arrêter les services
    image: docker.cnb.cool/frigate-cn/frigate:stable-rk # Il s'agit ici d'une URL de miroir nationale ; l'URL d'origine est ghcr.io/blakeblackshear/frigate:stable-rk
    shm_size: "512mb" # Mettez à jour cette valeur pour vos caméras selon le calcul ci-dessus
    devices:
      - /dev/dri:/dev/dri # Pour l'accélération matérielle GPU
      - /dev/dma_heap # RockChip DMA heap
      - /dev/rga # RockChip RGA
      - /dev/mpp_service # RockChip MPP service
    security_opt:
      - apparmor=unconfined
      - systempaths=unconfined
    volumes:
      - /etc/localtime:/etc/localtime:ro # Synchroniser l'heure de l'hôte
      - /home/seeed/frigate/config:/config # "/home/seeed/frigate/config" est le chemin sur votre hôte où vous souhaitez stocker les fichiers de configuration
      - /home/seeed/frigate/video:/media/frigate # "/home/seeed/frigate/video" est le chemin sur votre hôte où vous souhaitez stocker les vidéos de surveillance
      - type: tmpfs # Utiliser 1 Go de RAM comme stockage temporaire pour les segments d'enregistrement
        target: /tmp/cache
        tmpfs:
          size: 1000000000
      - /sys/:/sys/:ro # Informations système RockChip
    ports:
      - "8971:8971" # Port par défaut du service Frigate, HTTPS par défaut
      - "8554:8554" # Flux vidéo RTSP
      - "8555:8555/tcp" # WebRTC sur TCP
      - "8555:8555/udp" # WebRTC sur UDP
    environment:
      FRIGATE_RTSP_PASSWORD: "password" # Mot de passe RTSP ; veuillez le remplacer par celui souhaité
      TZ: "Asia/Shanghai" # Définir le fuseau horaire de la Chine +8
      HF_ENDPOINT: "https://huggingface.mirror.frigate-cn.video" # Miroir Huggingface national fourni par nos soins, pour accélérer le téléchargement de certains modèles requis par Frigate
      GITHUB_ENDPOINT: "https://github.mirror.frigate-cn.video" # Miroir GitHub national fourni par nos soins, pour accélérer le téléchargement de certains modèles requis par Frigate
      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 # Fichier de poids requis par le modèle de classification

Créez le fichier docker-compose.yml avec le contenu ci-dessus, puis exécutez dans le terminal :

bash
docker compose up -d

Une fois la construction terminée, Frigate est configuré localement. Vous pouvez ensuite modifier le fichier de configuration et, après le démarrage, vérifier le fonctionnement en arrière-plan.

config.yml minimale officielle

La config.yml suivante est une configuration minimale fonctionnelle : 1 caméra RTSP + MQTT désactivé + détecteur par défaut (CPU), fournie par défaut après l'installation de Frigate. Si vous ne disposez pas de ce fichier, vous devrez le créer manuellement.

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

Remplacez <camera-ip> par l'adresse IP réelle de votre caméra. Enregistrez ce fichier dans /path/to/your/config/config.yml (c'est-à-dire le /config mappé dans docker-compose).

Cette configuration peut également être modifiée pour exécuter plusieurs caméras simultanément. Il suffit d'ajouter d'autres structures sous la configuration ci-dessus. La configuration suivante démarre deux caméras avec des configurations détaillées différentes :

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  # Désactiver la détection au départ, pour tester d'abord le flux vidéo

    record:
      enabled: true
      continuous:
        days: 0 # Lorsqu'il est défini sur 0, par défaut aucune vidéo de surveillance sans type spécifié n'est enregistrée
      alerts: # Indique ici que seules les vidéos d'alarme sont enregistrées ; le réglage ci-dessus est ignoré
        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:  # Donnez un nom à cette caméra de test
    ffmpeg:
      inputs:
        - path: /home/seeed/frigate/test.mp4  # Chemin de votre fichier vidéo
          input_args: -re -stream_loop -1 -fflags +genpts
          roles:
            - detect
            - record
    detect:
      enabled: true
    record:
      enabled: false  # Il est recommandé de désactiver l'enregistrement pendant les tests
    snapshots:
      enabled: false  # Il est recommandé de désactiver les instantanés pendant les tests

version: 0.17-0

Démarrez cameras, video_test indentés, chacun représentant la configuration d'une caméra. ffmpeg indique la configuration globale de la caméra, y compris le chemin du fichier vidéo et les rôles d'application ; detect représente la fonction de détection d'objets, record la fonction d'enregistrement et snapshots la fonction d'instantanés.

Démarrage et vérification

Suivez le flux :

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

# Afficher les journaux de démarrage
sudo docker compose logs -f frigate

Si les journaux contiennent INFO : Frigate started successfully. ou si l'UI Web écoute sur 0.0.0.0:8971, le démarrage a réussi.

Recherchez des mots-clés dans les journaux pour récupérer le compte et le mot de passe :

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

Vous pourriez voir quelque chose comme rtsp://admin:password@192.168.1.100:554/stream.

bash
# Vérifier l'état du conteneur
sudo docker compose ps
# On attend que l'état du service Frigate soit running / healthy
bash
# Accès navigateur
https://<your-host-ip>:8971

Connectez-vous avec le compte et le mot de passe.

Une fois connecté, vous verrez la vue complète ainsi que les informations des caméras configurées dans le fichier de configuration précédent :

Sélectionnez-en une et cliquez pour entrer, puis cliquez en haut à droite pour accéder à l'interface de débogage, où vous verrez toutes les fonctions à l'écran. En haut à droite se trouvent les fonctions pouvant être configurées dans le fichier de configuration pour déterminer si elles sont incluses et si elles sont préchargées ; à gauche se trouvent les fonctions intégrées permettant de concevoir ultérieurement des frontières, etc. :