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