RK3576 Frigate : détection d’objets avec RKNN

Dernière mise à jour: 2026-11-11

Introduction

Le tutoriel précédent présentait l’installation de Frigate NVR sur reComputer RK3576 et l’accès à son interface web. Nous allons maintenant connecter une source vidéo et activer la détection d’objets avec la NPU RKNN pour reconnaître des personnes, des vélos et des voitures.

Vous pouvez utiliser une caméra IP RTSP externe ou un fichier vidéo local existant. Aucun exemple vidéo particulier n’est requis. Une fois la détection opérationnelle, une caméra RTSP compatible permet également de tester le décodage vidéo matériel RKMPP.

RKNN et RKMPP : RKNN accélère l’inférence des modèles d’IA sur la NPU du RK3576. RKMPP accélère le décodage vidéo grâce au matériel multimédia Rockchip. Il s’agit de deux chemins d’accélération distincts.

Les exemples suivent la configuration officielle de Frigate. Vérifiez la détection sur votre appareil.

Avant de commencer

Terminez d’abord le tutoriel Premiers pas avec Frigate NVR sur reComputer RK3576, puis vérifiez que vous pouvez vous connecter à https://<RK3576_IP>:8971.

Utilisez Linux avec un noyau BSP Rockchip compatible et le pilote RKNPU pour l’inférence RKNN. Le décodage RKMPP nécessite aussi le pilote vidéo Rockchip, notamment rkvdec2.

Ce guide reprend le répertoire ~/frigate-rk de la première partie, avec ./config monté dans /config et ./storage dans /media/frigate via Docker Compose. Il ne reprend pas les prérequis matériels, l’installation de Docker ni l’initialisation du compte administrateur.

Étape 1 : Sauvegarder la configuration Frigate existante

Connectez-vous au RK3576 par SSH et sauvegardez la configuration avant de la modifier :

bash

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

Frigate accepte config.yml et config.yaml. Si les deux existent, config.yml est prioritaire. Après avoir listé le répertoire, exécutez le bloc suivant pour sélectionner et sauvegarder le fichier existant ; les étapes suivantes utilisent le même chemin.

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

Si aucun des deux fichiers n’est trouvé, examinez les montages du conteneur :

bash

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

Repérez le répertoire de l’hôte monté dans /config, affectez-le à FRIGATE_CONFIG_DIR, puis répétez le listage et la sélection ci-dessus. Si votre déploiement définit un autre chemin de configuration, repérez ce fichier avant de continuer.

Si votre installation utilise un autre répertoire, adaptez les commandes. Conservez l’authentification et les réglages personnalisés des caméras lors de la fusion des exemples. Ne dupliquez pas les clés YAML de premier niveau telles que cameras:, detectors: ou model:.

Étape 2 : Choisir une source vidéo

Choisissez l’option A ou l’option B, pas les deux. Toutes deux utilisent le même détecteur RKNN configuré à l’étape 3.

Option A : Connecter une caméra IP RTSP externe

Cette option convient à un déploiement NVR réel et aux essais ultérieurs du décodage RKMPP.

Connectez la caméra IP à un réseau accessible depuis le RK3576.
Activez RTSP dans les paramètres de la caméra et notez son URL et ses identifiants. Par exemple :
text
```
rtsp://USERNAME:PASSWORD@CAMERA_IP:554/STREAM_PATH
```
Remplacez tous les paramètres fictifs par l’URL fournie par le fabricant.
Vous pouvez vérifier le flux RTSP sur le RK3576 avec ffprobe, fourni par le paquet 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'
```
Un flux opérationnel renvoie le codec vidéo et la résolution. Ne publiez pas de véritables identifiants.

Pour la détection, utilisez si possible le sous-flux 720p de la caméra. Un flux principal 4K ne fait qu’ajouter du décodage ; l’entrée du modèle reste 320×320.

Caméras USB : Une webcam USB n’est pas une caméra IP RTSP. Fournissez d’abord sa vidéo à Frigate avec une entrée compatible ou un pont RTSP ; ne remplacez pas l’URL RTSP de l’exemple par /dev/video0.

Option B : Utiliser un fichier vidéo local existant

Si vous n’avez pas de caméra IP, préparez votre propre fichier, par exemple un MP4 contenant des personnes ou des véhicules. Aucun téléchargement d’exemple précis n’est nécessaire.

Utilisez un MP4 1280×720, 15 fps, H.264, avec des personnes ou des véhicules suffisamment visibles. Si votre clip est plus grand, convertissez-le d’abord :

bash

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

Copiez ensuite le fichier test.mp4 converti vers storage/test.mp4 (remplacez le chemin dans la commande ci-dessous).

Copiez le fichier dans le dossier monté dans Frigate :

bash

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

Si le fichier se trouve sur votre ordinateur, vous pouvez aussi le transférer vers ~/frigate-rk/storage/test.mp4 avec SCP ou SFTP. Vérifiez sa visibilité dans le conteneur :

bash

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

Nous utilisons la méthode Manual Dummy Camera de Frigate, qui lit un fichier local en boucle avec FFmpeg.

Étape 3 : Configurer le détecteur RKNN et la caméra

Dans le même terminal SSH qu’à l’étape 1, ouvrez le fichier détecté. Si vous vous êtes reconnecté ou si la variable est vide, recommencez d’abord l’étape 1 :

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

Les deux options utilisent la configuration RKNN suivante :

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

Cet exemple utilise le modèle de détection RKNN frigate-fp16-yolov9-t. Les 320 × 320 correspondent à la taille d’entrée du modèle, pas à la résolution vidéo de la caméra. Le modèle est téléchargé au premier lancement puis mis en cache ; le premier téléchargement nécessite un accès réseau.

Pour une démonstration avec une seule source, choisissez l’un des exemples complets ci-dessous. Si vous devez conserver des paramètres existants, fusionnez les sections concernées au lieu de remplacer tout le fichier.

Configuration complète — Option A : Caméra RTSP

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

Important : Remplacez l’URL RTSP avant de redémarrer. L’enregistrement et les instantanés sont désactivés au départ pour se concentrer sur la détection.

Configuration complète — Option B : MP4 local

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 lit le fichier à sa cadence d’origine, -stream_loop -1 répète la lecture et -fflags +genpts génère les horodatages si nécessaire. Si le fichier local ne fonctionne pas avec le décodeur matériel, hwaccel_args: "" désactive l’accélération vidéo de cette caméra factice. La détection RKNN peut toujours s’exécuter sur la NPU.

Étape 4 : Redémarrer Frigate et vérifier l’initialisation de RKNN

Enregistrez le fichier sélectionné à l’étape 1 (config.yml ou config.yaml) et redémarrez le conteneur Frigate existant :

bash

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

Consultez les journaux pertinents sans afficher tout l’historique :

bash

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

Au premier lancement, patientez pendant le téléchargement et l’initialisation du modèle. Son cache doit être créé sous :

text

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

Vous pouvez examiner le cache avec :

bash

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

Poursuivez avec la vérification de l’étape 5.

Étape 5 : Vérifier les détections et l’utilisation de la NPU

Ouvrez https://<RK3576_IP>:8971 et connectez-vous.
Repérez la caméra configurée : front_door pour l’option A ou demo_video pour l’option B.
Ouvrez Debug view et activez Debugging Bounding Boxes. Des cadres portant les étiquettes person, bicycle ou car apparaissent autour des objets détectés.

Si aucun cadre n’apparaît, vérifiez que le clip contient un objet suivi, que Debugging Bounding Boxes est activé et que le journal affiche Successfully loaded RKNN model.
Dans la page System de Frigate, relevez le temps d’inférence du détecteur et les FPS de détection si votre version les affiche.
Sur le RK3576, vérifiez la charge de la NPU pendant que la vidéo contient des mouvements pertinents :
bash
```
sudo cat /sys/kernel/debug/rknpu/load
```
Vous pouvez aussi surveiller la charge en continu :
bash
```
watch -n 1 'sudo cat /sys/kernel/debug/rknpu/load'
```

L’utilisation de la NPU varie selon les mouvements. Vérifiez les détections dans la superposition et les métriques Frigate.

Étape 6 (facultatif) : Activer le décodage vidéo matériel RKMPP

Cette étape concerne surtout l’option A, caméra RTSP, une fois la détection RKNN opérationnelle. RKMPP accélère le décodage de vidéos compatibles ; ce n’est pas le détecteur d’objets.

Ajoutez hwaccel_args: preset-rkmpp dans ffmpeg: pour la caméra front_door existante :

yaml

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

Cet exemple est partiel : conservez les autres réglages de caméra, de modèle RKNN et de détecteur de l’étape 3.

Redémarrez Frigate et consultez les journaux FFmpeg :

bash

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

Vérifiez que la vidéo et les détections fonctionnent toujours, que FFmpeg ne plante pas en boucle avec des erreurs de contexte matériel et, si l’hôte dispose des outils nécessaires, que le décodeur vidéo est actif. Comparez la charge CPU avec le même flux et la même résolution avant et après l’activation de RKMPP.

Pour la caméra factice utilisant un MP4 local, laissez le décodage matériel désactivé lors de la première vérification RKNN.

PrécédentRK3576 Frigate NVR : installation

SuivantBenchmarks de vision par ordinateur sur RK3576 et RK3588