RK3576 Frigate: detección de objetos con RKNN

Última actualización: 2026-11-11

Introducción

En el tutorial anterior instalamos Frigate NVR en reComputer RK3576 y accedimos a su interfaz web. Ahora conectaremos una fuente de vídeo y activaremos la detección de objetos con la NPU RKNN para reconocer personas, bicicletas y coches.

Puedes utilizar una cámara IP RTSP externa o un archivo de vídeo local que ya tengas. No se requiere ningún vídeo de ejemplo concreto. Una vez que funcione la detección, quienes tengan una cámara RTSP compatible también podrán probar la decodificación de vídeo por hardware RKMPP.

RKNN y RKMPP: RKNN acelera la inferencia de los modelos de IA en la NPU del RK3576. RKMPP acelera la decodificación de vídeo mediante el hardware multimedia de Rockchip. Son dos rutas de aceleración independientes.

Los ejemplos siguen la configuración oficial de Frigate. Verifica la detección en tu equipo.

Antes de empezar

Completa primero Primeros pasos con Frigate NVR en reComputer RK3576 y confirma que puedes iniciar sesión en https://<RK3576_IP>:8971.

Utiliza Linux con un kernel BSP Rockchip compatible y el controlador RKNPU para la inferencia RKNN. La decodificación RKMPP también requiere el controlador de vídeo Rockchip, incluido rkvdec2.

Esta guía utiliza el directorio ~/frigate-rk de la primera parte, con ./config montado en /config y ./storage en /media/frigate mediante Docker Compose. No repite los requisitos de hardware, la instalación de Docker ni la configuración inicial del administrador.

Paso 1: Guarda una copia de la configuración de Frigate

Conéctate al RK3576 por SSH y crea una copia antes de editar:

bash

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

Frigate admite config.yml y config.yaml. Si existen ambos, tiene prioridad config.yml. Tras listar el directorio, ejecuta el siguiente bloque para seleccionar y guardar una copia del archivo existente; los pasos posteriores utilizan la misma ruta.

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 no se encuentra ninguno de los archivos, inspecciona los montajes del contenedor:

bash

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

Localiza el directorio del anfitrión montado en /config, asigna esa ruta a FRIGATE_CONFIG_DIR y repite el listado y la selección anteriores. Si tu despliegue define otra ruta de configuración, localiza ese archivo antes de continuar.

Si utilizas otro directorio, adapta los comandos. Conserva la autenticación y los ajustes personalizados de las cámaras al integrar los ejemplos. No dupliques claves YAML de nivel superior como cameras:, detectors: o model:.

Paso 2: Selecciona una fuente de vídeo

Elige la opción A o la opción B, no ambas. Las dos usan el mismo detector RKNN del paso 3.

Opción A: Conecta una cámara IP RTSP externa

Esta opción es adecuada para un NVR real y para probar posteriormente la decodificación RKMPP.

Conecta la cámara IP a una red accesible desde el RK3576.
Activa RTSP en la configuración de la cámara y anota su URL RTSP y credenciales. Por ejemplo:
text
```
rtsp://USERNAME:PASSWORD@CAMERA_IP:554/STREAM_PATH
```
Sustituye todos los marcadores por la URL proporcionada por el fabricante.
Opcionalmente, comprueba el flujo en el RK3576 con ffprobe, incluido en el paquete 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 flujo funcional devuelve el códec y la resolución del vídeo. No publiques credenciales reales.

Para la detección, usa el subflujo 720p de la cámara si está disponible. Un flujo principal 4K solo añade carga de decodificación; la entrada del modelo sigue siendo 320×320.

Cámaras USB: Una webcam USB no es una cámara IP RTSP. Primero facilita el vídeo a Frigate mediante una entrada compatible o un puente RTSP; no sustituyas la URL RTSP del ejemplo por /dev/video0.

Opción B: Utiliza un archivo de vídeo local existente

Si no tienes cámara IP, prepara un vídeo propio, como un MP4 con personas o vehículos. No necesitas descargar un vídeo de ejemplo específico.

Usa un MP4 1280×720, 15 fps, H.264, con personas o vehículos suficientemente visibles. Si tu vídeo es más grande, conviértelo primero:

bash

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

Después, copia el test.mp4 convertido a storage/test.mp4 (sustituye la ruta en el comando de abajo).

Copia el archivo a la carpeta montada en 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 el archivo está en tu ordenador, también puedes transferirlo a ~/frigate-rk/storage/test.mp4 con SCP o SFTP. Verifica que el contenedor pueda verlo:

bash

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

Utilizaremos el método Manual Dummy Camera de Frigate, que lee y reproduce en bucle un archivo local con FFmpeg.

Paso 3: Configura el detector RKNN y la cámara

En el mismo terminal SSH del paso 1, abre el archivo detectado. Si te has reconectado o la variable está vacía, repite primero el paso 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

Ambas opciones usan esta configuración del detector RKNN:

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

Este ejemplo utiliza el modelo de detección RKNN frigate-fp16-yolov9-t. Los 320 × 320 corresponden al tamaño de entrada del modelo, no a la resolución de la cámara. El modelo se descarga automáticamente la primera vez y después se utiliza la caché; la primera descarga requiere acceso a la red.

Para una demostración con una sola fuente, elige uno de los ejemplos completos siguientes. Si debes conservar ajustes existentes, integra las secciones pertinentes en lugar de reemplazar todo el archivo.

Configuración completa: Opción A, cámara 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

Importante: Sustituye la URL RTSP antes de reiniciar. Al principio se desactivan las grabaciones y las instantáneas para centrarse en la detección de objetos.

Configuración completa: Opción 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 lee el archivo a su velocidad original, -stream_loop -1 repite la reproducción y -fflags +genpts genera marcas de tiempo cuando es necesario. Si el archivo local no funciona con el decodificador por hardware, hwaccel_args: "" desactiva la aceleración de vídeo para esta cámara simulada. La detección RKNN puede seguir ejecutándose en la NPU.

Paso 4: Reinicia Frigate y comprueba la inicialización de RKNN

Guarda el archivo seleccionado en el paso 1 (config.yml o config.yaml) y reinicia el contenedor existente:

bash

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

Consulta los registros relevantes sin mostrar todo el historial:

bash

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

La primera vez, espera a que el modelo se descargue y se inicialice. Su caché se crea en:

text

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

Puedes examinar la caché con:

bash

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

Continúa con la verificación del paso 5.

Paso 5: Verifica las detecciones y el uso de la NPU

Abre https://<RK3576_IP>:8971 e inicia sesión.
Busca la cámara configurada: front_door en la opción A o demo_video en la opción B.
Abre Debug view y activa Debugging Bounding Boxes. Alrededor de los objetos detectados aparecen recuadros con las etiquetas person, bicycle o car.

Si no aparecen recuadros, comprueba que el vídeo contenga un objeto rastreado, que Debugging Bounding Boxes esté activado y que el registro muestre Successfully loaded RKNN model.
Abre la página System de Frigate y consulta el tiempo de inferencia del detector y los FPS de detección, si la versión instalada los muestra.
En el RK3576, comprueba la carga de la NPU mientras el vídeo contiene movimiento relevante:
bash
```
sudo cat /sys/kernel/debug/rknpu/load
```
También puedes supervisarla de forma continua:
bash
```
watch -n 1 'sudo cat /sys/kernel/debug/rknpu/load'
```

El uso de la NPU fluctúa según el movimiento. Confirma las detecciones en la superposición y en las métricas de Frigate.

Paso 6 (opcional): Activa la decodificación por hardware RKMPP

Utiliza este paso principalmente con la opción A, cámara RTSP, cuando la detección RKNN ya funcione. RKMPP acelera la decodificación de vídeo compatible; no es el detector de objetos.

Añade hwaccel_args: preset-rkmpp dentro de ffmpeg: en la cámara front_door existente:

yaml

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

Este es un ejemplo parcial: conserva el resto de los ajustes de la cámara, el modelo RKNN y el detector del paso 3.

Reinicia Frigate y revisa los registros de 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

Comprueba que el vídeo y las detecciones siguen funcionando, que FFmpeg no se reinicia continuamente por errores de contexto de hardware y, si dispones de herramientas en el anfitrión, que el decodificador esté activo. Compara el uso de CPU con el mismo flujo y resolución antes y después de activar RKMPP.

Para la cámara simulada con MP4 local, deja desactivada la decodificación por hardware durante la primera verificación de RKNN.

AnteriorRK3576 Frigate NVR: instalación

SiguienteBenchmarks de visión artificial en RK3576 y RK3588