Installer Frigate sur un Raspberry Pi 5 avec un Google Coral TPU

Frigate est un enregistreur vidéo réseau facile à mettre en place sur un Raspberry Pi, notamment grâce à ses images Docker prêtes à l’emploi. Son interface simple le rend particulièrement accessible pour surveiller son domicile ou son bureau.

Ce dont vous aurez besoin

Le matériel nécessaire est le même que pour notre configuration PyCoral avec un Raspberry Pi 5, car nous utilisons le même accélérateur Google Coral TPU pour décharger les tâches de détection d’objets du CPU de la carte.

Vous aurez donc besoin d’un Raspberry Pi 5 avec la dernière version de Raspberry Pi OS installée sur une carte microSD, ainsi que d’un chapeau PCIe pour connecter votre Google Coral TPU.

Pour un usage intensif comme l’enregistrement constant de flux vidéo, nous recommandons plutôt un HatDrive! AI qui permet de faire cohabiter le TPU et un stockage NVMe rapide. Pour des tests ou une utilisation légère, une bonne carte microSD peut suffire.

Configurer le Raspberry Pi 5 pour le TPU

Vérifier les mises à jour du système

Votre installation étant fraîche, les mises à jour sont probablement inutiles, mais il est bon de vérifier. Exécutez ces commandes :

sudo apt update 
sudo apt upgrade

Modifier le fichier config.txt

Ouvrez /boot/firmware/config.txt avec votre éditeur de texte favori (en utilisant sudo) et ajoutez ces lignes à la fin du fichier.

kernel=kernel8.img 
dtoverlay=pineboards-hat-ai

Ces lignes activent la connexion PCIe (bien qu’elle le soit généralement par défaut), basculent le noyau sur une taille de bloc de 4K (requise par le Coral TPU) et activent l’overlay de l’arborescence de périphériques spécifique au chapeau AI de Pineboards.

Redémarrez ensuite avec sudo reboot.

Après le redémarrage, vérifiez avec uname -a que la version du noyau Linux s’est bien mise à jour. Vous devriez voir 6.6.31+rpt-rpi-v8, et c’est bien le v8 à la fin qui confirme le succès.

Pour vérifier que le Google Coral est bien reconnu, lancez :

lspci | grep Coral

Vous devriez obtenir System peripheral: Global Unichip Corp. Coral Edge TPU. Sinon, revoyez les branchements physiques et les étapes précédentes.

Installer les pilotes du Coral TPU

À partir de maintenant, suivez notre guide sur la configuration du Google Coral TPU sur Raspberry Pi 5 à partir de l’étape 3, qui détaille l’installation des pilotes et logiciels nécessaires.

Installer Docker sur le Raspberry Pi 5

Suivez les instructions officielles de Docker pour ajouter son dépôt apt. Exécutez cette série de commandes :

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
  $(. /etc/os-release && echo \"$VERSION_CODENAME\") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

Cela ajoute la clé GPG de Docker, installe quelques paquets requis et intègre le dépôt APT de Docker à vos sources. Vous pouvez ensuite installer les paquets :

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-compose

Après confirmation de l’installation, Docker est prêt.

Créer le conteneur Docker de Frigate

Docker est la méthode d’installation recommandée par les créateurs de Frigate. Notre configuration cible un Google Coral TPU PCIe, un stockage local pour les enregistrements et une caméra réseau utilisant le protocole RTSP.

Créer les fichiers et répertoires nécessaires

Nous allons créer les répertoires pour la configuration et le stockage. Ici, nous utilisons /home/user/frigate/config/ et /home/user/frigate/storage/.

mkdir -p /home/user/frigate/config 
mkdir -p /home/user/frigate/storage

Créez ensuite un fichier de configuration dans ce répertoire :

nano /home/user/frigate/config/config.yml

Insérez-y le contenu suivant, en adaptant l’adresse IP de votre caméra (ici, 192.168.1.123) :

mqtt:
  enabled: False
detectors:
  coral:
    type: edgetpu
    device: pci 
cameras:
  living_room:
    enabled: False
    ffmpeg:
      inputs:
        - path: rtsp://192.168.1.123/stream1
          roles:
            - detect

Docker Compose

Nous allons maintenant configurer le déploiement Docker via un fichier docker-compose.yml. Placez-vous dans le répertoire principal et créez-le :

cd /home/user/frigate 
nano docker-compose.yml

Puis collez-y cette configuration, en n’oubliant pas de modifier le mot de passe sur la dernière ligne :

version: "3.9"
services:
  frigate:
    container_name: frigate
    privileged: true # this may not be necessary for all setups
    restart: unless-stopped
    image: ghcr.io/blakeblackshear/frigate:stable
    shm_size: "64mb" # update for your cameras based on calculation above
    devices:
      - /dev/apex_0:/dev/apex_0    # Passes a PCIe Coral, follow driver instructions here https://coral.ai/docs/m2/get-started/#2a-on-linux
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /home/user/frigate/config:/config
      - /home/user/frigate/storage:/media/frigate
      - type: tmpfs # Optional: 1GB of memory, reduces SSD/SD Card wear
        target: /tmp/cache
        tmpfs:
          size: 1000000000
    ports:
      - "5000:5000"
      - "8554:8554" # RTSP feeds
      - "8555:8555/tcp" # WebRTC over tcp
      - "8555:8555/udp" # WebRTC over udp
    environment:
      FRIGATE_RTSP_PASSWORD: "pineberriesandcream"

Pour lancer le conteneur, utilisez docker-compose :

sudo docker-compose up -d

Si tout se passe bien, vous pourrez accéder à votre instance Frigate à l’adresse http://[IP-DE-VOTRE-PI]:5000. L’interface devrait confirmer que le Coral TPU est reconnu et que la caméra est correctement configurée.

Tester la détection d’objets

Dans l’interface de Frigate, rendez-vous sur la page de votre caméra. Dans le coin supérieur droit, cliquez sur « Debug » puis activez l’option « Bounding box ». Si vous passez devant la caméra, celle-ci devrait vous détecter et vous identifier comme une personne (ou un animal, le cas échéant).

Conclusion

Vous disposez désormais d’une installation Frigate de base avec une caméra et une détection d’objets prise en charge par le Google Coral TPU, ce qui libère le CPU du Raspberry Pi.

Les possibilités sont vastes : enregistrement continu, déclenchement à la détection de mouvement, ou intégration avec un système domotique comme Home Assistant. Pour explorer toutes les fonctionnalités, consultez la documentation complète de Frigate.

Retrouvez l’histoire de Raspberry Pi dans cette vidéo :