Reconnaissance Faciale – partie 1

Salutation, je te propose une suite de plusieurs articles sur la détection de personne mais aussi sur la reconnaissance faciale.
Il n’y a rien de vraiment compliqué à mettre en place mais il faut un peu de matériel, comme un autre support indépendant de Home Assistant.

Je vais utilisé Frigate, Double Take et CompreFace, il existe des modules complémentaires pour HA mais lorsque j’ai testé, HA était indisponible le temps de la détection des visages, bon faut dire que j’ai fait ça sur une VM, sans CORAL, tout sur le CPU à l’arrache 😉

Donc pour ne pas mettre HA en PLS à chaque fois que quelqu’un passe devant la caméra j’ai préféré installé Frigate et CompreFace sur un Raspberry Pi 5 séparée de HA, par contre j’ai laissé Double Take en module complémentaire HA, ça passe (avec une seule caméra pour l’instant)

J’ai commandé un CORAL qui est en cours d’envoie, je manquerai pas de mettre à jour les articles après mes tests.

Pour finir avec les explications, j’ai fait ça dans le but de mettre en place une sonnette connecté filaire avec caméra.
2 objectifs :
– Si un inconnu approche de la porte, avoir une notification le plus rapidement possible
– Si une personne autorisée approche de la porte, désactiver l’alarme (on a tendance à l’oublier et le chat devient cardiaque avec la sirène 😉 )

Installation de Docker et Docker compose

Passons dans le vif du sujet, on va partir du principe que le Raspberry pi fonctionne déjà, il faut installer Docker et Docker Compose

Il y a énormément de tuto sur le sujet mais le site officiel est assez bien fait, depuis un terminal vous lancez ça :

# 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

Pour faire simple ça va télécharger les certificats et ajouter le dépot docker

Ensuite on installe Docker et Docker-Compose depuis le dépot nouvellement ajouté

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

se qui manque dans la doc officielle : Lancer Docker au démarrage du Pi :

systemctl enable docker.service
systemctl enable containerd.service

Installation de Portainer

Portainer est une interface graphique qui permet de gérer Docker, grâce à lui il est plus simple de superviser ou même d’installer une image/Stack Docker

Portainer n’est rien d’autre qu’une image Docker, donc on l’installe avec ces commandes :

docker run -d -p 9000:9000 --name portainer \
    --restart=always \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v portainer_data:/data \
    portainer/portainer-ce:latest

Maintenant que Portainer est installé on peut s’y connecté depuis un navigateur web sur le port 9000, chez mois ça sera : http://192.168.1.47:9000/
Il t’invite à créer un mot de passe sur le login admin.

Maintenant que tout est en place il faut préparer l’arrivée de Frigate.
Le docker est en gros un moteur qui va utiliser des répertoires de notre Raspberry Pi, en fait si on a besoin de mettre à jour Frigate, il faudra supprimer notre docker et relancer l’installation de son image, nous ne perdrons pas les données car elles seront sur un répertoire du Raspberry Pi.

On crée un premier répertoire grâce à la commande mkdir, dans mon exemple j’utilise le répertoire /mnt/nfs-backup qui en fait un monté sur un partage de mon Synology mais ça ne change rien, si tu laisses les données sur le Pi la commande est identique :

mkdir -p /mnt/nfs-backup

Ensuite on va créer un second répertoire qui contiendra le fichier configuration : config.yaml

mkdir -p /opt/data/frigate/

Une fois le répertoire créer on peut créer le fichier de configuration :

nano /opt/data/frigate/config.yaml

Voici mon fichier config.yaml :

mqtt:
    enabled: true
    host: 192.168.1.zzz # adresse IP de HA avec Mosquitto
    port: 1883
    user: mqtt_user
    password: P@ssW0rdMqtt
cameras:
    garage: #ma caméra qui s'appelle garage
      ffmpeg:
        inputs:
          - path: rtsp://login:P@ssW0rd@192.168.1.xxx:yy/videoSub # flux vidéo de la camera, avec l'IP et le port
            roles:
              - detect
      onvif: # permet de diriger la camera si elle est compatible
        host: 192.168.1.xxx
        port: 888
        user: login
        password: P@ssW0rd
      objects:
        track: # se que l'on souhaite détecter
          - person
          - cat
      snapshots:
        enabled: True
      record:
        enabled: True
        retain: # par défaut je n'enregistre pas
          days: 0
          mode: all
        events: # si il y a un évènement je garde la vidéo 14 jours
          retain:
            default: 14
            mode: motion

Il faut bien sur adapter ce fichier avec l’IP de ta caméra, l’IP de ton MQTT ainsi que les différents login.
La liste complète des options est sur le site officiel : https://docs.frigate.video/configuration/

Après quelques semaines d’utilisation, voici une configuration un peu plus optimisée avec l’utilisation de go2rtc qui permet d’optimiser les performances.

mqtt:
  enabled: true
  host: 192.168.1.zzz   # adresse IP de HA avec Mosquitto
  port: 1883
  user: mqtt_user
  password: P@ssw0rd
detectors: # prise en charge du CORAL
  coral:
    type: edgetpu
    device: usb
cameras:
  garage:   #ma caméra qui s'appelle garage
    ffmpeg:
      inputs:
      - path: rtsp://127.0.0.1:8554/garage     # flux vidéo de la camera, avec l'IP est en 127.0.0.1 car récupéré de go2rtc - voir plus bas
        input_args: preset-rtsp-restream
        roles:
        - detect
    onvif:   # permet de diriger la camera si elle est compatible
      host: 192.168.1.yyy
      port: 888
      user: login
      password: P@ssw0rd
    detect:
      fps: 5
      enabled: true
    objects:
      track:   # se que l'on souhaite détecter
      - person
      - cat
    snapshots:
      enabled: true
    record:
      enabled: true
      retain:   # par défaut je n'enregistre pas
        days: 0
        mode: all
      events:   # si il y a un évènement je garde la vidéo 14 jours
        retain:
          default: 14
          mode: motion
go2rtc:
  streams:
    garage: rtsp://login:password@192.168.1.zzz:88/videoMain

  webrtc:
    listen: :8555
    candidates:
    - 82.YYY.XXX.ZZZ:8555 # permet la vue depuis l'exterieur du LAN

Tu pourras remarqué que dans cameras : je fais appel à une IP en 127.0.0.1, c’est tout a fait volontaire et il faut absoluement laisser cette IP car finalement FRIGATE va récupérer le flux video de go2rtc qui est configuré à la fin du fichier.
– path: rtsp://127.0.0.1:8554/garage
Le /garage correspond au nom donné dans go2rtc :

go2rtc:
  streams:
    garage: rtsp://login:password@192.168.1.zzz:88/videoMain

Une fois le fichier créé avec nano, pour l’enregistrer il faut faire CTRL + X

On va maintenant retourner sur Portainer pour préparer le fichier Docker Compose qui va télécharger et configurer le docker avec les infos qu’on va lui donner

Il faut aller dans Stacks puis à droite : Add Stack

Je te laisse renseigner le nom et le Build method comme sur la capture

Pour le Web editor :

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
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /opt/data/frigate/config.yaml:/config/config.yaml
      - /mnt/nfs-backup:/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: "P@ssw0rd"

Voila le contenu de mon Docker-compose, il y a plus d’option, surtout si tu utilises un CORAL, site officiel : https://docs.frigate.video/frigate/installation

Il faut évidemment personnalisé un peu ce code, surtout pour les lignes de volumes

Ne pas oublier de changer le mot de passe en dernière ligne.

Il ne reste plus qu’à cliquer sur Deploy the stack tout en bas de la page, le déploiement peut prendre un peu de temps sachant qu’il va télécharger l’image de frigate.
une fois que c’est terminée tu devrais pouvoir aller dans ton navigateur et taper l’IP de ton Raspberry PI suivi du port 5000 et te voila sur Frigate, par exemple http://192.168.1.213:5000/

C’est bien beau mais Home Assistant maintenant ?

Est bien il suffit de télécharger un module complémentaire via HACS dans Intégrations, recherche Frigate et installe le.
Ensuite il faut activer l’intégration en allant dans les Paramètres de HA -> Appareils et services

Ajouter une intégration (en bas à droite) et rechercher Frigate :

Tout en bas de la fenêtre il faut renseigner l’IP de Frigate, dans mon exemple : http://192.168.1.213:5000

Voila, tu as normalement 2 nouveaux appareils, Frigate et le nom donnée à la camera : garage

Si je vais dans Frigate_Garage, je vais avoir différents sensor dont la détection de personne et de chat, se qui correspond à se que j’ai indiqué dans le fichier config.yaml de Frigate

Je te laisse t’amuser avec ça pour le moment, la partie 2 est dispo avec l’installation de Double Take et CompreFace