RK3576 Frigate: objectdetectie met RKNN

Laatst bijgewerkt:

Inleiding

In de vorige handleiding installeerden we Frigate NVR op reComputer RK3576 en openden we de webinterface. Nu sluiten we een videobron aan en schakelen we RKNN-NPU-objectdetectie in om personen, fietsen en auto’s te herkennen.

Je kunt een externe RTSP-IP-camera of een bestaand lokaal videobestand gebruiken. Er is geen specifiek voorbeeldbestand nodig. Zodra objectdetectie werkt, kun je met een geschikte RTSP-camera ook RKMPP-hardwarevideodecodering testen.

RKNN en RKMPP: RKNN versnelt de inferentie van AI-modellen op de NPU van de RK3576. RKMPP versnelt videodecodering via de multimediahardware van Rockchip. Het zijn afzonderlijke versnellingspaden.

De voorbeelden volgen de officiële Frigate-configuratie. Verifieer de detectie op je apparaat.

Voordat je begint

Voltooi eerst Aan de slag met Frigate NVR op reComputer RK3576 en controleer of je kunt aanmelden op https://<RK3576_IP>:8971.

Gebruik Linux met een geschikte Rockchip-BSP-kernel en de RKNPU-driver voor RKNN-inferentie. Voor RKMPP is ook de Rockchip-videodecoderdriver nodig, waaronder rkvdec2.

Deze handleiding gebruikt de projectmap ~/frigate-rk uit deel 1, met ./config gekoppeld aan /config en ./storage aan /media/frigate in Docker Compose. De hardwarevereisten, Docker-installatie en eerste beheerdersconfiguratie worden niet herhaald.

Stap 1: Maak een back-up van de bestaande Frigate-configuratie

Maak via SSH verbinding met de RK3576 en maak een back-up voordat je de configuratie bewerkt:

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

Frigate ondersteunt config.yml en config.yaml. Als beide bestaan, krijgt config.yml voorrang. Voer na het bekijken van de map het volgende blok uit om het bestaande bestand te selecteren en er een back-up van te maken. De volgende stappen gebruiken hetzelfde pad.

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

Wordt geen van beide bestanden gevonden, bekijk dan de koppelingen van de container:

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

Zoek de hostmap die aan /config is gekoppeld, stel FRIGATE_CONFIG_DIR in op die map en herhaal de bovenstaande opdrachten voor het bekijken en selecteren. Als je installatie een afwijkend configuratiepad gebruikt, zoek dat bestand dan eerst op.

Pas de opdrachten aan als je een andere installatiemap gebruikt. Behoud bestaande authenticatie en aangepaste camera-instellingen wanneer je de voorbeelden samenvoegt. Maak geen dubbele YAML-sleutels op het hoogste niveau, zoals cameras:, detectors: of model:.

Stap 2: Kies een videobron

Kies optie A of optie B, niet beide. Beide gebruiken dezelfde RKNN-detector uit stap 3.

Optie A: Sluit een externe RTSP-IP-camera aan

Deze optie is geschikt voor een echte NVR-installatie en latere tests met RKMPP-decodering.

  1. Verbind de IP-camera met een netwerk dat vanaf de RK3576 bereikbaar is.

  2. Schakel RTSP in via de camera-instellingen en noteer de RTSP-URL en aanmeldgegevens. Bijvoorbeeld:

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

    Vervang alle tijdelijke aanduidingen door de URL van de camerafabrikant.

  3. Controleer de RTSP-stream eventueel op de RK3576 met ffprobe uit het pakket 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'

    Een werkende stream geeft de videocodec en resolutie terug. Publiceer geen echte aanmeldgegevens.

    Gebruik voor detectie indien beschikbaar de 720p-substream van de camera. Een 4K-hoofdstream voegt alleen decodeerwerk toe; de modelinvoer blijft 320×320.

USB-camera’s: Een USB-webcam is geen RTSP-IP-camera. Maak de video eerst beschikbaar voor Frigate via een compatibele invoermethode of RTSP-bridge. Gebruik /dev/video0 niet als vervanging in de RTSP-voorbeeld-URL.

Optie B: Gebruik een bestaand lokaal videobestand

Heb je geen IP-camera, gebruik dan een eigen videobestand, zoals een MP4 met personen of voertuigen. Je hoeft geen specifieke voorbeeldvideo te downloaden.

Gebruik een 1280×720, 15 fps, H.264 MP4 waarin personen of voertuigen duidelijk zichtbaar zijn. Is je clip groter, converteer deze dan eerst:

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

Kopieer daarna de geconverteerde test.mp4 naar storage/test.mp4 (vervang het pad in de opdracht hieronder).

Kopieer het bestand naar de map die aan Frigate is gekoppeld:

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

Staat het bestand op je computer, dan kun je het ook met SCP of SFTP naar ~/frigate-rk/storage/test.mp4 overzetten. Controleer of de container het bestand kan zien:

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

We gebruiken de Manual Dummy Camera-methode van Frigate, die een lokaal bestand via FFmpeg in een lus afspeelt.

Stap 3: Configureer de RKNN-detector en camera

Open het gevonden configuratiebestand in dezelfde SSH-terminal als in stap 1. Ben je opnieuw verbonden of is de variabele leeg, herhaal dan eerst stap 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

Beide opties gebruiken de volgende RKNN-detectorconfiguratie:

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

Dit voorbeeld gebruikt het RKNN-detectiemodel frigate-fp16-yolov9-t. De 320 × 320 is de invoergrootte van het model, niet de videoresolutie van de camera. Het model wordt bij het eerste gebruik automatisch gedownload en daarna uit de cache geladen; de eerste download vereist netwerktoegang.

Kies voor een demonstratie met één bron een van de volledige voorbeelden hieronder. Moeten bestaande instellingen behouden blijven, voeg dan de relevante secties samen in plaats van het volledige bestand te vervangen.

Volledige configuratie — Optie A: RTSP-camera

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

Belangrijk: Vervang de RTSP-URL voordat je opnieuw start. Opnamen en snapshots zijn eerst uitgeschakeld om de test op objectdetectie te richten.

Volledige configuratie — Optie 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 leest het bestand op zijn oorspronkelijke snelheid, -stream_loop -1 herhaalt de weergave en -fflags +genpts maakt zo nodig tijdstempels. Werkt het lokale bestand niet met de hardwaredecoder, dan schakelt hwaccel_args: "" de videohardwareversnelling voor deze dummycamera uit. RKNN-objectdetectie kan nog steeds op de NPU draaien.

Stap 4: Herstart Frigate en controleer de RKNN-initialisatie

Sla het in stap 1 geselecteerde bestand (config.yml of config.yaml) op en herstart de bestaande Frigate-container:

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

Bekijk de relevante logs zonder de volledige geschiedenis af te drukken:

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

Wacht bij het eerste gebruik tot het model is gedownload en geïnitialiseerd. De cache wordt hieronder aangemaakt:

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

Je kunt de cache controleren met:

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

Ga verder met de controle tijdens het draaien in stap 5.

Stap 5: Controleer de detectieresultaten en het NPU-gebruik

  1. Open https://<RK3576_IP>:8971 en meld je aan.

  2. Zoek de geconfigureerde camera: front_door bij optie A of demo_video bij optie B.

  3. Open Debug view en schakel Debugging Bounding Boxes in. Rond gedetecteerde objecten verschijnen kaders met de labels person, bicycle of car.

    Debug view van Frigate met detectiekaders rond gedetecteerde voertuigen

    Verschijnen er geen kaders, controleer dan of de clip een gevolgd object bevat, Debugging Bounding Boxes is ingeschakeld en de logs Successfully loaded RKNN model tonen.

  4. Open de pagina System in Frigate en bekijk de inferentietijd van de detector en de detectie-FPS als jouw versie die toont.

  5. Controleer op de RK3576 de NPU-belasting terwijl de video relevante beweging bevat:

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

    Je kunt de belasting ook herhaaldelijk volgen:

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

Het NPU-gebruik schommelt met de beweging. Controleer de detecties in de overlay en de Frigate-metrieken.

Stap 6 (optioneel): Schakel RKMPP-hardwarevideodecodering in

Gebruik deze stap vooral met optie A, RTSP-camera, nadat de RKNN-detectie werkt. RKMPP versnelt de decodering van geschikte video en is niet de objectdetector.

Voeg hwaccel_args: preset-rkmpp toe onder ffmpeg: voor de bestaande camera front_door:

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

Dit is een gedeeltelijk voorbeeld: behoud de overige camera-, RKNN-model- en detectorinstellingen uit stap 3.

Herstart Frigate en bekijk de 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

Controleer of de camerastream en AI-detecties blijven werken en FFmpeg niet herhaaldelijk crasht door hardwarecontextfouten. Controleer ook of de videodecoder actief is als daarvoor tools op de host beschikbaar zijn. Vergelijk het CPU-gebruik bij dezelfde stream en resolutie vóór en na het inschakelen van RKMPP.

Laat hardwaredecodering bij de dummycamera met een lokale MP4 uitgeschakeld tijdens de eerste RKNN-controle.