Systèmes de vidéosurveillance

Présentation de Frigate et Frigate+

Présentation

Installation de Docker et Frigate

Frigate repose sur docker, que j'ai installé tout simplement en tapant sur ma Mageia

urpmi docker docker-compose

on lance ensuite docker en tapant

systemctl start docker

voilà son statut

systemctl status docker

et le résultat

● docker.service - Docker Application Container Engine
     Loaded: loaded (/usr/lib/systemd/system/docker.service; disabled; preset: disabled)
     Active: active (running) since Fri 2025-09-26 17:02:55 CEST; 6s ago
       Docs: http://docs.docker.com
    Process: 210883 ExecStartPre=/usr/sbin/docker-network-cleanup (code=exited, status=0/SUCCESS)
   Main PID: 210886 (dockerd)
      Tasks: 17
     Memory: 41.1M
        CPU: 369ms
     CGroup: /system.slice/docker.service
             ├─210886 /usr/sbin/dockerd --data-root /var/cache/docker -H unix:///var/run/docker.sock -H tcp://127.0.0.1:2375
             └─210899 containerd --config /var/run/docker/containerd/containerd.toml

sept. 26 17:02:52 ultra.kervao.fr dockerd[210899]: time="2025-09-26T17:02:52.687489959+02:00" level=info msg=serving... address=/var/run/docker/containerd/containerd.sock
sept. 26 17:02:52 ultra.kervao.fr dockerd[210899]: time="2025-09-26T17:02:52.687576078+02:00" level=info msg="containerd successfully booted in 0.201550s"
sept. 26 17:02:54 ultra.kervao.fr dockerd[210886]: time="2025-09-26T17:02:54.283134739+02:00" level=info msg="Loading containers: start."
sept. 26 17:02:55 ultra.kervao.fr dockerd[210886]: time="2025-09-26T17:02:55.007460149+02:00" level=info msg="Loading containers: done."
sept. 26 17:02:55 ultra.kervao.fr dockerd[210886]: time="2025-09-26T17:02:55.281188368+02:00" level=warning msg="WARNING: API is accessible on http://127.0.0.1:2375 without encryption>
sept. 26 17:02:55 ultra.kervao.fr dockerd[210886]: time="2025-09-26T17:02:55.281244407+02:00" level=info msg="Docker daemon" commit=library-import containerd-snapshotter=false storage>
sept. 26 17:02:55 ultra.kervao.fr dockerd[210886]: time="2025-09-26T17:02:55.281378785+02:00" level=info msg="Daemon has completed initialization"
sept. 26 17:02:55 ultra.kervao.fr dockerd[210886]: time="2025-09-26T17:02:55.804448712+02:00" level=info msg="API listen on /var/run/docker.sock"
sept. 26 17:02:55 ultra.kervao.fr systemd[1]: Started docker.service.
sept. 26 17:02:55 ultra.kervao.fr dockerd[210886]: time="2025-09-26T17:02:55.804558097+02:00" level=info msg="API listen on 127.0.0.1:2375"

pour voir si docker fonctionne correctement on tapera

docker run hello-world

voilà le résultat

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
17eec7bbc9d7: Pull complete
Digest: sha256:54e66cc1dd1fcb1c3c58bd8017914dbed8701e2d8c74d9262e26bd9cc1642d31
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

pour que docker soit lancé à chaque reboot, on tapera

systemctl enable docker

on créera le répertoire /etc/frigate et /etc/frigate/config, les enregistrements se feront dans le répertoire /media/frigate. On revient sous /etc/frigate/config dans lequel j'ai créé le fichier docker-compose.yml qui contiendra

services:
  frigate:
    container_name: frigate
    privileged: true # this may not be necessary for all setups
    network_mode: host # j'ai dû rajouter cette ligne pour accéder à ma caméra restreamée avec mediamtx
    restart: unless-stopped
    stop_grace_period: 30s # allow enough time to shut down the various services
    image: ghcr.io/blakeblackshear/frigate:stable
    shm_size: "512mb" # update for your cameras based on calculation above
    devices:
     - /dev/bus/usb:/dev/bus/usb # ligne pour l'accélérateur USB Google Coral, à commenter sinon
     - /dev/dri/renderD128:/dev/dri/renderD128 # For intel hwaccel, needs to be updated for your hardware
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /etc/frigate/config:/config
      - /media/frigate:/media/frigate
      - type: tmpfs # Optional: 1GB of memory, reduces SSD/SD Card wear
        target: /tmp/cache
        tmpfs:
          size: 1000000000
    ports: #section inutile avec le mode réseau host
      - "8971:8971" # port de l'interface navigateur
      #- "8554:8554" # RTSP feeds, j'ai mis en commentaire car conflit avec mediamtx, utile pour renvoyer le flux vidéo vers homeassistant
      - "8555:8555/tcp" # WebRTC over tcp
      - "8555:8555/udp" # WebRTC over udp

[retour haut de la page]

et config.yaml dans lequel on définira les caméras et les objets à détecter (liste par ici https://docs.frigate.video/configuration/objects)

mqtt:
  enabled: false
cameras:
  Camera-sud:
    ffmpeg:
      inputs:
        - path: rtsp://frigate:passwd@192.168.2.110
          roles:
            - detect
            - record
      hwaccel_args: preset-vaapi
    objects:
      track:
        - person
        - dog
        - cat
        - bird
        - bicycle
        - car
        - motorcycle
    detect:
      width: 1280
      height: 720
    record:
      enabled: true
      retain:
        days: 7
        mode: all
  Camera-entree:
    ffmpeg:
      inputs:
        - path: rtsp://frigate:passwd@192.168.2.112
          roles:
            - detect
            - record
      hwaccel_args: preset-vaapi
    objects:
      track:
        - person
        - dog
        - cat
        - bird
        - bicycle
        - car
        - motorcycle
    detect:
      width: 1280
      height: 720
    record:
      enabled: true
      retain:
        days: 7
        mode: all
  Camera-piscine:
    ffmpeg:
      inputs:
        - path: rtsp://frigate:passwd@192.168.2.200:554/ch0_1.264
          roles:
            - detect
            - record
    objects:
      track:
        - person
        - dog
        - cat
        - bird
    detect:
      width: 800
      height: 448
    record:
      enabled: true
      retain:
        days: 7
        mode: all
  Camera-ouest:
    ffmpeg:
      inputs:
        - path: rtsp://ultra.kervao.fr:8554/cam1
          roles:
            - detect
            - record
    objects:
      track:
        - person
        - dog
        - cat
        - bird
    detect:
      width: 640
      height: 360
    record:
      enabled: true
      retain:
        days: 7
        mode: all
detectors:
  cpu1:
    type: cpu
    num_threads: 3
detect:
  enabled: true
version: 0.16-0

si vous avez un accélérateur USB Google Coral, on mettra à la place au niveau de detectors

 coral:
    type: edgetpu
    device: usb

on tape ensuite dans ce même répertoire

docker compose -f docker-compose.yml up -d

voilà le résultat                                                                                                                                          9.6s

+] Running 10/10
 ✔ frigate 9 layers [⣿⣿⣿⣿⣿⣿⣿⣿⣿]      0B/0B      Pulled                                                                                                                           79.5s
   ✔ b1badc6e5066 Pull complete                                                                                                                                                   1.2s
   ✔ 4f4fb700ef54 Pull complete                                                                                                                                                   0.3s
   ✔ 14d4601b76c8 Pull complete                                                                                                                                                  14.6s
   ✔ cab46c26a5aa Pull complete                                                                                                                                                   1.1s
   ✔ 6891a7512d41 Pull complete                                                                                                                                                  14.3s
   ✔ b44b002328e4 Pull complete                                                                                                                                                   8.3s
   ✔ 8074b201d282 Pull complete                                                                                                                                                   8.6s
   ✔ d823104cefbd Pull complete                                                                                                                                                   9.0s
   ✔ f86078113133 Pull complete                                                                                                                                                   9.6s
[+] Running 2/2
 ✔ Network config_default  Created                                                                                                                                                0.1s
 ✔ Container frigate       Started

Premier lancement

C'est bon Frigate est installé, lancé et accessible du navigateur localement en tapant

https://ultra.kervao.fr:8971/

pour connaitre le mot de passe il faudra taper

docker logs frigate

et on y voit

2025-09-26 17:46:21.528704726  [2025-09-26 17:46:21] frigate.app                    INFO    : ********************************************************
2025-09-26 17:46:21.529867665  [2025-09-26 17:46:21] frigate.app                    INFO    : ********************************************************
2025-09-26 17:46:21.530590965  [2025-09-26 17:46:21] frigate.app                    INFO    : ***    Auth is enabled, but no users exist.          ***
2025-09-26 17:46:21.531237207  [2025-09-26 17:46:21] frigate.app                    INFO    : ***    Created a default user:                       ***
2025-09-26 17:46:21.542212889  [2025-09-26 17:46:21] frigate.app                    INFO    : ***    User: admin                                   ***
2025-09-26 17:46:21.566794613  [2025-09-26 17:46:21] frigate.app                    INFO    : ***    Password: 2bf8aeb98g16b66f54e70a8e8f121076   ***
2025-09-26 17:46:21.577589942  [2025-09-26 17:46:21] frigate.app                    INFO    : ********************************************************
2025-09-26 17:46:21.598394530  [2025-09-26 17:46:21] frigate.app                    INFO    : ********************************************************

avec un TPU on devrait avoir un message qui ressemble à ça

2025-10-30 07:55:40.442764361  [2025-10-30 07:55:40] frigate.detectors.plugins.edgetpu_tfl INFO    : TPU found
2025-10-30 07:55:40.443899970  INFO: Created TensorFlow Lite XNNPACK delegate for CPU.

cela permet de pouvoir se connecter et voilà l'interface générale avec les derniers évènements en haut et les vues en direct juste en dessous

Avec seulement le TPU, autant dire que c'est inutilisable au quotidien, le programme prend quasiment 100% des ressources constamment.

et avec un TPU, c'est le jour et la nuit !!

[retour haut de la page]

Configuration

Avant d'aller plus loin il est important de connaitre quelques notions à la base du fonctionnement de Frigate, on parle d'alertes et de détections, les alertes sont à la base des détections mais considérées comme des évènements prioritaires à signaler alors que les détections sont des évènements peu significatifs, qui ne méritent pas de notification mais qui sont tout de même enregistrées et visibles dans la revue des évènements (voir la documentation en anglais ici https://docs.frigate.video/configuration/review/).

Passons à la configuration accessible via la roue crantée en bas à gauche de l'écran principal. Dans le premier onglet Interface Utilisateur, il y a des paramètres généraux que je n'ai pas modifiés, dans l'onglet Données augmentées, on peut activer (ils sont désactivés par défaut)

• la recherche sémantique qui permet de retrouver les objets suivis dans votre revue d'évènements en utilisant soit l'image elle-même, soit une description textuelle définie par l'utilisateur, soit une description générée automatiquement.
• la reconnaissance faciale
• la reconnaissance des plaques d'immatriculation
• l'identification des oiseaux
  

On commence par l'onglet Masques/Zones, pour chaque caméra sélectionnable à partir du bouton bleu en haut à droite on déclare des zones de détection, les autres zones de l'image seront ignorées pour la détection

A noter qu'on peut sélectionner le type d'objet qui peut être détecté et estimer la vitesse du mouvement.

En revanche si on souhaite que seules les personnes et les voitures soient considérées comme des alertes, il faudra modifier le fichier de configuration pour la caméra en question au niveau de la section review en rajoutant une sous section labels comme ceci

    review:
      alerts:
        labels:
          - person
          - car
        required_zones: Zone-det-camera-sud
      detections:
        required_zones: Zone-det-camera-sud

On peut également déclarer des masques de mouvement pour empêcher la détection à des endroits où on risque d'avoir des mouvements indésirables (végétation), ça peut perturber le suivi des objets.

pour que votre voiture garée habituellement à sa place n'apparaisse pas comme un faux positif, il faudra créer un masque d'objet particulier comme ceci

A noter qu'il faudra relancer Frigate pour que ça soit pris en compte, c'est possible à partir du menu des Paramètres.

On revient maintenant à l'onglet Paramètres Des Caméras, dans la configuration ci-dessous, seulement les objets Personne et Voiture seront affichées sous forme d'alertes dans la zone prédéfinie et les autres objets détectés seront classés détections dans la même zone.

et ainsi de suite pour toutes les caméras.

Dans l'onglet Réglages Du Mouvement, on peut affiner certains paramètres pour chaque caméra pour que ça soit considéré comme un mouvement, j'ai laissé les valeurs par défaut.

L'onglet Debogage peut être intéressant pour afficher en temps réel certaines informations. L'onglet Utilisateurs comme son nom l'indique permet de gérer les utilisateurs, deux types d'utilisateurs sont possibles les administrateurs accèdent à l'ensemble des fonctionnalités de l'interface, les observateurs sont limités à la consultation des caméras, de la revue d'événements et à l'historique des enregistrements dans l'interface utilisateur. L'onglet Notifications permet d'envoyer des mails pour les alertes.

Pour ce qui concerne les enregistrements, par défaut on a

    record:
      enabled: true
      retain:
        days: 7
        mode: all

c'est à dire qu'alerte comme détection sont enregistrées et conservées 7 jours. Pour une gestion plus fine des enregistrements, voir cette page https://docs.frigate.video/configuration/record/

[retour haut de la page]

Régler la détection d'objet

En mettant la résolution maximum de ma caméra à 3072x1728, voilà à quoi correspond une boîte de 320x320 pixels, ce n'est pas la panacée pour la détection mais c'est déjà mieux.

• score : c'est un paramètre non modifiable calculé à chaque image pour chaque objet détecté
  
• min_score : tous les objets détectés dont le score est inférieur à ce paramètre seront ignorées
  
• threshold : c'est la moyenne des scores pour un objet détecté sur plusieurs images consécutives
  

Frigate calcule un score pour chaque objet détecté à chaque image et l'objet est considéré comme positif quand à la fois le score dépasse le min_score et le threshold, c'est à dire la moyenne des scores sur plusieurs images consécutives, ce dernier paramètre permet de confirmer la détection.
Voilà ce qu'on pourra rajouter au fichier config.yaml comme section commune pour l'ensemble des caméras, ce sont des valeurs communément partagées par la communauté des utilisateurs de Frigate.

objects:
  filters:
    dog:
      min_score: .7
      threshold: .9
    cat:
      min_score: .65
      threshold: .8
    person:
      min_score: .7
      threshold: .9
    car:
      min_score: .65
      threshold: .85

Il ne faut pas considérer ces valeurs comme des valeurs idéales, pour ma part avec des caméras extérieures qui ont plutôt tendance à avoir un champ de vision plus lointain, j'ai préféré rajouter une sous section filters à chaque section objects de chacune de mes caméras pour pouvoir ajuster ces valeurs en fonction des caméras, comme ceci

    objects:
      track:
        - person
        - dog
        - cat
        - face
      filters:
        person:
          min_score: .7
          threshold: .8

 [Retour haut de la page]

Activer la détection des visages

Pour activer la détection des visages, on commencera par rajouter la section correspondante dans le fichier config.yaml

face_recognition:
  enabled: true

et pour les caméras concernées on rajoutera dans la sous section track la mention face

objects:
      track:
        - person
        - dog
        - cat
        - bicycle
        - car
        - motorcycle
        - face

On relance Frigate et les logs renvoient les messages suivantes

2025-11-02 11:20:57.493001613  [2025-11-02 11:20:57] frigate.config.config          WARNING : Camera-entree is configured to track ['face'] objects, which are not supported by the current model.
2025-11-02 11:20:57.495025758  [2025-11-02 11:20:57] frigate.config.config          WARNING : Camera-piscine is configured to track ['face'] objects, which are not supported by the current model.
2025-11-02 11:20:57.519957917  [2025-11-02 11:20:57] frigate.app                    INFO    : Starting Frigate (0.16.1-e664cb2)
2025-11-02 11:20:57.520656637  [2025-11-02 11:20:57] frigate.app                    INFO    : Creating directory: /media/frigate/clips/faces

(...)

2025-11-02 11:20:58.822822712  [2025-11-02 11:20:58] frigate.api.fastapi_app        INFO    : FastAPI started
2025-11-02 11:21:00.117012864  [2025-11-02 11:21:00] frigate.util.downloader        INFO    : Downloading complete: https://github.com/NickM-27/facenet-onnx/releases/download/v1.0/facenet.tflite
2025-11-02 11:21:00.269584095  [2025-11-02 11:21:00] frigate.detectors.plugins.edgetpu_tfl INFO    : TPU found
2025-11-02 11:21:00.270930420  INFO: Created TensorFlow Lite XNNPACK delegate for CPU.
2025-11-02 11:21:03.456767865  [2025-11-02 11:21:03] frigate.util.downloader        INFO    : Downloading complete: https://github.com/NickM-27/facenet-onnx/releases/download/v1.0/landmarkdet.yaml

Une icône Bibliothèque de visages fait son apparition

On rajoute des visages connus en cliquant sur Ajouter un visage, j'ai sélectionné pour commencer deux images de face bien identifiables, une à une

Ensuite on clique sur le bouton Entraîner en haut à gauche et on télécharge des images avec la personne dans différentes situations

 [Retour haut de la page]

il rajoute la photo en zoomant sur le visage s'il a été clairement identifié, il est recommandé de rajouter au total de 20 à 30 images pour que ça soit le plus robuste, c'est un peu laborieux à faire car il faut y aller image par image. Sur ma configuration les images seront placées sous /media/frigate/clips/faces
Et voilà ce que ça va donner quand il identifie les personnes

Maintenant vous pouvez entraîner les modèles en cliquant sur l’icône , on peut confirmer la détection en cliquant sur les personnes qui ont été créées précédemment.

En revanche si Frigate se trompe en affichant un faux positif, on peut les supprimer en les sélectionnant à l'aide la commande CTRL. Puis le bouton en haut à droite Supprimer les visages

Plus d'information par ici https://docs.frigate.video/configuration/face_recognition.

 [Retour haut de la page]

Connecter une caméra orientable PTZ compatible ONVIF

On peut également animer les caméras PTZ via le protocole ONVIF, on pourra utiliser OnvifDeviceManager présenté ici pour détecter comment accéder aux paramètres ONVIF de la caméra. Dans le fichier config.yaml au niveau la caméra concernée on rajoutera une section onvif après la section ffmpeg, comme ceci :

  Camera-est:
    ffmpeg:
      inputs:
        - path: rtsp://user:motdepasse@192.168.2.187:554/11
          roles:
            - detect
            - record
      hwaccel_args: []
  onvif:
      host: 192.168.2.187
      port: 8080
      user: "user"
      password: "motdepasse"

on relance Frigate et les commandes font leur apparition dans l'interface

dans les logs, à chaque commande cela donne

2025-12-14 16:23:19.863412328  [2025-12-14 16:23:19] frigate.comms.dispatcher       INFO    : Setting ptz command to OnvifCommandEnum.move_down for Camera-est
2025-12-14 16:23:20.014362034  [2025-12-14 16:23:20] frigate.comms.dispatcher       INFO    : Setting ptz command to OnvifCommandEnum.stop for Camera-est
2025-12-14 16:23:24.154372463  [2025-12-14 16:23:24] frigate.comms.dispatcher       INFO    : Setting ptz command to OnvifCommandEnum.move_left for Camera-est
2025-12-14 16:23:24.324886496  [2025-12-14 16:23:24] frigate.comms.dispatcher       INFO    : Setting ptz command to OnvifCommandEnum.stop for Camera-est
2025-12-14 16:23:27.660911995  [2025-12-14 16:23:27] frigate.comms.dispatcher       INFO    : Setting ptz command to OnvifCommandEnum.move_left for Camera-est
2025-12-14 16:23:27.831550797  [2025-12-14 16:23:27] frigate.comms.dispatcher       INFO    : Setting ptz command to OnvifCommandEnum.stop for Camera-est
2025-12-14 16:23:31.340495182  [2025-12-14 16:23:31] frigate.comms.dispatcher       INFO    : Setting ptz command to OnvifCommandEnum.move_left for Camera-est
2025-12-14 16:23:31.471007427  [2025-12-14 16:23:31] frigate.comms.dispatcher       INFO    : Setting ptz command to OnvifCommandEnum.stop for Camera-est
2025-12-14 16:23:35.053131483  [2025-12-14 16:23:35] frigate.comms.dispatcher       INFO    : Setting ptz command to OnvifCommandEnum.move_left for Camera-est
2025-12-14 16:23:35.203476745  [2025-12-14 16:23:35] frigate.comms.dispatcher       INFO    : Setting ptz command to OnvifCommandEnum.stop for Camera-est
2025-12-14 16:23:38.560508556  [2025-12-14 16:23:38] frigate.comms.dispatcher       INFO    : Setting ptz command to OnvifCommandEnum.move_left for Camera-est
2025-12-14 16:23:38.691835827  [2025-12-14 16:23:38] frigate.comms.dispatcher       INFO    : Setting ptz command to OnvifCommandEnum.stop for Camera-est

 [Retour haut de la page]

Rajouter un certificat Let's Encrypt

Par défaut Frigate génère un certificat auto signé pour utiliser le port 8971 ce qui génère un avertissement de sécurité dans le navigateur, sous Firefox on peut accepter le risque pour pouvoir y accéder. Mais c'est pas génial d'autant plus si on accède à Frigate d'internet. Dans la configuration qui est présentée ici on utilisera apache et non nginx comme c'est présenté un peu partout. Pour la configuration de Let's Encrypt avec apache on consultera cette page.
Le principe est le suivant

Internet -> HTTPS port 443 -> reverse proxy -> HTTP interne -> Frigate port 8971

Apache fait office reverse proxy, c'est à dire qu'il permet d’accéder à une URL interne en modifiant automatiquement l'URL et en pointant vers le bon port. Mon adresse accessible sur internet est https://adresseperso.ddns.net qui pointe déjà sur une page index.html, cette configuration permet donc d'accéder à frigate à l'adresse https://adresseperso.ddns.net/frigate

Dans le fichier de configuration d'apache httpd.conf, on activera les modules suivants:

LoadModule proxy_module modules/mod_proxy.so 
LoadModule proxy_http_module modules/mod_proxy_http.so

et on rajoutera l'hôte virtuel

<VirtualHost 192.168.2.13:443>
   ServerName adresseperso.ddns.net

   SSLEngine on
   SSLCertificateFile /etc/letsencrypt/live/adresseperso.ddns.net/fullchain.pem
   SSLCertificateKeyFile /etc/letsencrypt/live/adresseperso.ddns.net/privkey.pem

   ProxyPreserveHost On
   ProxyRequests Off

   # Redirection vers Frigate sur port 8971
   ProxyPass /frigate http://127.0.0.1:8971/frigate
   ProxyPassReverse /frigate http://127.0.0.1:8971/frigate

   # Websocket support
   RewriteEngine On
   RewriteCond %{HTTP:Upgrade} =websocket [NC]
   RewriteRule ^/frigate/(.*) ws://127.0.0.1:8971/frigate/$1 [P,L]
</VirtualHost>

on relance apache en tapant systemctl restart httpd

dans le fichier docker-compose.yml on modifiera dans la section environnement le chemin par défaut en rajoutant

environment:
     FRIGATE_BASE_PATH: "/frigate"

Pour prendre en compte les modifications on stoppera Frigate en tapant docker stop frigate  puis

docker compose -f docker-compose.yml up -d

et on relance Frigate en tapant docker start frigate

[retour haut de la page]

Utilisation

Revenons maintenant à l'interface principale, on a vu plus haut que la vue principale renvoie vers les vues des caméras, elle est accessible en cliquant sur l'icône représentant une caméra sur la gauche.

En cliquant à gauche sur la Revue des évènements, on voit s'afficher tous les derniers évènements (alertes, détections, mouvement). L'objet détecté apparait en icône dans le coin en haut à gauche de l'image, on accède au replay en cliquant sur l'image. On acte la revue en cliquant en bas sur Marquer ces éléments comme passés en revue

Quand on clique sur la petite icône en haut à gauche qui symbolise l'objet détecté, on tombe sur les détails de l'évènement, on peut aller encore plus loin en cliquant sur le symbole  à droite de l'objet détecté

On voit un zoom sur l'objet détecté et si on clique sur on obtient un menu, on clique sur Visualiser le cycle de vie de l'objet

on peut visualiser sa trajectoire sur la zone de détection, il me semble pas avoir trouvé de fonctions pour invalider une détection/alerte sur un faux positif, fonction qu'on retrouve dans la version payante Frigate+

Le menu Explorer à gauche permet d'afficher tous les objets détectés qu'on peut filtrer avec les outils en haut à droite

Vous pouvez les supprimer un à un à l'aide du menu contextuel, ou par paquet avec un CTRL-A puis le bouton Supprimer en haut à droite

On a vu plus haut qu'on pouvait accéder à un état des ressources du système via le menu Système->Indicateurs systèmes, il y a également un onglet Stockage qui donne un état des enregistrements

Et l'onglet Caméras qui donne un état des ressources utilisées par chaque caméra, même si on ne voit pas le TPU

Pour le reste,  je vous renvoie à la documentation de frigate pour l'utilisation avec quelques URL intéressantes

https://docs.frigate.video/guides/getting_started
https://community.jeedom.com/t/tuto-integrer-frigate-et-faire-de-la-reconnaissance-video-dobjet-par-ia-en-local-dans-son-jeedom/117108
https://www.simplehomelab.com/frigate-docker-guide/

Visualiser Frigate d'un mobile

Pour ce qui concerne la visualisation à distance sur un mobile, il existe bien une application Android non officielle, mais j'en vois pas trop l'intérêt car de base en accédant directement à l'adresse (dès lors qu'on l'a rendu accessible sur internet) à partir d'un navigateur du mobile, c'est plutôt convivial comme on peut le voir ci-dessous

 [Retour haut de la page]

Notifications avec Signal via MQTT

Présentation

Frigate intègre déjà un service de notification par mail comme évoqué plus haut qui ne marche pas chez moi, mais peu importe ce paragraphe explique recevoir les notifications d'alerte avec Signal en utilisant le service MQTT. MQTT (Message Queuing Telemetry Transport) est un protocole de messagerie qui fonctionne sur le principe de souscription / publication, c'est à dire qu'un serveur (ou broker) peut publier des notifications sur un canal et des clients peuvent soucrire pour visualiser les notifications. Pour ce qui concerne Frigate, en activant MQTT, on pourra lancer un script qui déclenche une action à la réception d'un évènement comme une alerte, il est possible également que le broker MQTT soit accessible d'internet et une application cliente MQTT android peut être installé pour être prévenu des alertes.

Installation de Mosquitto

Le site officiel https://mosquitto.org, sur ma mageia je me suis contenté de l'installer en tapant

urpmi mosquitto

on crée un utilisateur avec son mot de passe

mosquitto_passwd -c /etc/mosquitto/passwd  olivier
Password:  
Reenter password:

dans le fichier /etc/mosquitto/mosquitto.conf on décommente et modifie les deux lignes suivantes

allow_anonymous false

password_file /etc/mosquitto/passwd

on change le propriétaire du fichier passwd

chown mosquitto:mosquitto /etc/mosquitto/passwd

on peut lancer mosquitto

systemctl start mosquitto

et voilà ce que donne la commande systemctl status mosquitto

● mosquitto.service - Mosquitto MQTT Broker
    Loaded: loaded (/usr/lib/systemd/system/mosquitto.service; disabled; preset: disabled)
    Active: active (running) since Sun 2025-12-07 09:14:56 CET; 2min 12s ago
      Docs: man:mosquitto.conf(5)
            man:mosquitto(8)
   Process: 1426932 ExecStartPre=/bin/mkdir -m 740 -p /var/log/mosquitto (code=exited, status=0/SUCCESS)
   Process: 1426933 ExecStartPre=/bin/chown mosquitto:mosquitto /var/log/mosquitto (code=exited, status=0/SUCCESS)
   Process: 1426934 ExecStartPre=/bin/mkdir -m 740 -p /run/mosquitto (code=exited, status=0/SUCCESS)
   Process: 1426935 ExecStartPre=/bin/chown mosquitto:mosquitto /run/mosquitto (code=exited, status=0/SUCCESS)
  Main PID: 1426936 (mosquitto)
     Tasks: 1 (limit: 18901)
    Memory: 1004.0K
       CPU: 43ms
    CGroup: /system.slice/mosquitto.service
            └─1426936 /usr/sbin/mosquitto -c /etc/mosquitto/mosquitto.conf

déc. 07 09:14:56 ultra.kervao.fr systemd[1]: Starting mosquitto.service...
déc. 07 09:14:56 ultra.kervao.fr mosquitto[1426936]: 1765095296: mosquitto version 2.0.21 starting
déc. 07 09:14:56 ultra.kervao.fr mosquitto[1426936]: 1765095296: Config loaded from /etc/mosquitto/mosquitto.conf.
déc. 07 09:14:56 ultra.kervao.fr mosquitto[1426936]: 1765095296: Starting in local only mode. Connections will only be possible from clients running on this machine.
déc. 07 09:14:56 ultra.kervao.fr mosquitto[1426936]: 1765095296: Create a configuration file which defines a listener to allow remote access.
déc. 07 09:14:56 ultra.kervao.fr mosquitto[1426936]: 1765095296: For more details see https://mosquitto.org/documentation/authentication-methods/
déc. 07 09:14:56 ultra.kervao.fr mosquitto[1426936]: 1765095296: Opening ipv4 listen socket on port 1883.
déc. 07 09:14:56 ultra.kervao.fr mosquitto[1426936]: 1765095296: Opening ipv6 listen socket on port 1883.
déc. 07 09:14:56 ultra.kervao.fr mosquitto[1426936]: 1765095296: mosquitto version 2.0.21 running
déc. 07 09:14:56 ultra.kervao.fr systemd[1]: Started mosquitto.service.

on n'oublie pas d'ouvrir le port TCP 1883 utilisé par MQTT via shorewall

Pour voir si ça fonctionne bien on peut lancer un client qui va attendre une notification d'un broker

mosquitto_sub -v -t 'test/topic' -u olivier -P motdepasse

Maintenant on va lancer un broker en publiant une notification

mosquitto_pub -u olivier -P motdepasse -t 'test/topic' -m 'helloWorld'

et du client on va voir s'afficher

test/topic helloWorld

A noter que le broker tourne sur le serveur où se trouve Frigate, l'ensemble tourne en local et je n'ai pas besoin qu'il soit accessible d'internet.

 [Retour haut de la page]

Configuration de Frigate et scripts de gestion des alertes

Maintenant dans le fichier de configuration de Frigate config.yaml, on va activer MQTT

mqtt:
 enabled: true
 host: localhost
 user: olivier
 password: motdepasse
 port: 1883

on va créer le script d'écoute /usr/local/bin/alerte_frigate qui va envoyer un mail dès qu'il y a une alerte, on verra plus loin pour Signal.

#!/bin/bash
mosquitto_sub -t "frigate/events" -u olivier -P motdepasse | while read -r payload
do
   #à décommenter pour visualiser pour des tests de fonctionnemnet
   #echo "Rx MQTT: ${payload}"
   #envoi d'un mail pour chaque nouveau évènement
   if echo "${payload}" | grep -q '"type": "new"'; then
       echo "${payload}" | mail -s "Frigate alerte" olivier
   fi
done

le mail contiendra

{"before": {"id": "1765103169.376268-4ybyyv", "camera": "Camera-sud", "frame_time": 1765103169.376268, "snapshot": null, "label": "car", "sub_label": null, "top_score": 0.0, "false_positive": true, "start_time": 1765103169.376268, "end_time": null, "score": 0.9765625, "box": [1876, 1001, 2407, 1285], "area": 150804, "ratio": 1.869718309859155, "region": [1356, 0, 3072, 1716], "active": true, "stationary": false, "motionless_count": 0, "position_changes": 0, "current_zones": [], "entered_zones": [], "has_clip": false, "has_snapshot": false, "attributes": {}, "current_attributes": [], "pending_loitering": false, "max_severity": null, "current_estimated_speed": 0, "average_estimated_speed": 0, "velocity_angle": 0, "path_data": [], "recognized_license_plate": null}, "after": {"id": "1765103169.376268-4ybyyv", "camera": "Camera-sud", "frame_time": 1765103169.59021, "snapshot": {"frame_time": 1765103169.376268, "box": [1876, 1001, 2407, 1285], "area": 150804, "region": [1356, 0, 3072, 1716], "score": 0.9765625, "attributes": [], "current_estimated_speed": 0, "velocity_angle": 0, "path_data": [], "recognized_license_plate": null, "recognized_license_plate_score": null}, "label": "car", "sub_label": null, "top_score": 0.9765625, "false_positive": false, "start_time": 1765103169.376268, "end_time": null, "score": 0.9765625, "box": [1872, 1003, 2411, 1287], "area": 153076, "ratio": 1.897887323943662, "region": [1356, 0, 3072, 1716], "active": true, "stationary": false, "motionless_count": 1, "position_changes": 0, "current_zones": [], "entered_zones": [], "has_clip": false, "has_snapshot": false, "attributes": {}, "current_attributes": [], "pending_loitering": false, "max_severity": null, "current_estimated_speed": 0, "average_estimated_speed": 0, "velocity_angle": 0, "path_data": [[[0.6969, 0.7448], 1765103169.59021]], "recognized_license_plate": null}, "type": "new"}

le script va filtrer les nouvelles alertes uniquement, en revanche il prendra aussi bien les alertes que les détections, il n'existe pas de champs qui les distinguent.

Voilà un script plus évolué (merci ChatGPT !!) qui permettra d'envoyer un mail d'alerte uniquement pour les objets person et car en y joignant la photo instantanée avec le contour autour de l'objet. Il nécessitera l'installation du package jq qui permettra d'extraire plus facilement des informations utiles.

#!/bin/bash
# /usr/local/bin/alerte_frigate
# Attendre que le clip soit complètement écrit (taille stable) avant envoi

MQTT_USER="olivier"
MQTT_PASS="motdepasse"
MQTT_TOPIC="frigate/events"

CLIP_DIR="/media/frigate/clips"
FRIGATE_API="http://localhost:8971"
MAIL_TO="olivier"

LOGGER_TAG="alerte_frigate"

### --- LOG FUNCTION ---
log()     { logger -t "$LOGGER_TAG" "[INFO] $*"; }
log_warn(){ logger -t "$LOGGER_TAG" "[WARN] $*"; }
log_dbg() { logger -t "$LOGGER_TAG" "[DEBUG] $*"; }

# Paramètres d'attente pour la stabilité du fichier
WAIT_MAX_SECS=20       # temps max d'attente pour que le fichier soit complet
CHECK_STEP=0.5         # intervalle entre deux vérifs de taille (sec)
STABLE_ROUNDS=2        # nombre de mesures identiques successives pour considérer "stable"

mosquitto_sub -t "$MQTT_TOPIC" -u "$MQTT_USER" -P "$MQTT_PASS" | while read -r payload
do
   # Ne traiter que les "new"
   if echo "$payload" | jq -e . >/dev/null 2>&1; then
       if ! echo "$payload" | grep -q '"type"[[:space:]]*:[[:space:]]*"new"'; then
           continue
       fi
   else
       continue
   fi

   # Extraire infos
   camera=$(echo "$payload" | jq -r '.after.camera // .camera // empty')
   label=$(echo "$payload" | jq -r '.after.label // "inconnu"')
   id=$(echo "$payload" | jq -r '.after.id // .id // empty')


   # Filtrer uniquement les labels car et person
   if [[ "${label}" != "car" && "${label}" != "person" ]]; then
       log_dbg "Événement ignoré pour label=${label}"
       continue
   fi

   if [ -z "$id" ] || [ -z "${camera}" ]; then
       log_warn "Événement MQTT invalide, ignoré."
       continue
   fi

   EVENT_ID="$id"
   log "Détection : caméra=${camera}, label=${label}, id=${EVENT_ID}"
   log_dbg "Recherche du fichier annoté…"
   
   # il faut attendre que Frigate crée le fichier et ne pas aller trop vite, ça peut prendre quelques secondes
   CLIP_FILE=""
   MAX_WAIT=10   # secondes
   WAIT=0  
   while [ $WAIT -lt $MAX_WAIT ]; do
       CLIP_FILE=$(find "$CLIP_DIR" -type f -iname "*${EVENT_ID}*.jpg" | head -n 1)

       if [ -n "$CLIP_FILE" ]; then
               log_dbg "Fichier trouvé après ${WAIT}s : $CLIP_FILE"
               break
       fi

       sleep 1
       WAIT=$((WAIT+1))
   done

   if [ -z "$CLIP_FILE" ]; then
          log_warn "Aucun snapshot annoté trouvé pour $EVENT_ID après ${MAX_WAIT}s."
   else
       log "[INFO] Clip annoté trouvé:  $CLIP_FILE"

   fi

   ATTACH=""
   # Si clip trouvé, attendre la stabilisation de la taille
   if [[ -n "$CLIP_FILE" && -f "$CLIP_FILE" ]]; then
       log "Clip candidate trouvé: $CLIP_FILE"
       elapsed=0
       stable_count=0
       last_size=-1

       while (( $(echo "$elapsed < $WAIT_MAX_SECS" | bc -l) )); do
           if [[ -f "$CLIP_FILE" ]]; then
               size=$(stat -c %s "$CLIP_FILE" 2>/dev/null || echo 0)
           else
               size=0
           fi

           if [[ "$size" -eq "$last_size" && "$size" -gt 0 ]]; then
               stable_count=$((stable_count+1))
           else
               stable_count=0
           fi

           # Si on a STABLE_ROUNDS mesures identiques => on le considère complet
           if (( stable_count >= STABLE_ROUNDS )); then
               log "Fichier stable (taille=$size). Prêt à être envoyé."
               ATTACH="$CLIP_FILE"
               break
           fi

           last_size=$size
           sleep "$CHECK_STEP"
           elapsed=$(echo "$elapsed + $CHECK_STEP" | bc -l)
       done

       # si pas stable au bout du timeout, on considère quand même (mais on peut fallback)
       if [[ -z "$ATTACH" ]]; then
           log_warn "Fichier non stable après ${WAIT_MAX_SECS}s (taille actuelle=${last_size}). Tentative fallback API."
       fi
   else
       log_warn "Aucun clip annoté trouvé localement pour ${EVENT_ID}."
   fi

   # Si pas d'attach encore, tenter de récupérer la snapshot via API
   if [[ -z "$ATTACH" ]]; then
       TMPFILE="/tmp/frigate_snapshot_${EVENT_ID//[^a-zA-Z0-9._-]/_}.jpg"
       rm -f "$TMPFILE"

       # Récupération via API (retry court car la snapshot peut être générée juste après l'event)
       got=0
       retries=8
       sleep_between=0.5
       for ((i=0;i<retries;i++)); do
           curl -s -f "${FRIGATE_API}/api/events/${EVENT_ID}/snapshot.jpg" -o "$TMPFILE"
           if [[ $? -eq 0 && -s "$TMPFILE" ]]; then
               log "Snapshot récupérée via API -> $TMPFILE"
               ATTACH="$TMPFILE"
               got=1
               break
           fi
           sleep "$sleep_between"
       done

       if [[ $got -ne 1 ]]; then
           echo "[WARN] API snapshot échouée ou introuvable pour ${EVENT_ID}."
       fi
   fi

   # Corps et envoi du mail
   subject="Frigate : détection de ${label} sur ${camera}"
   body="Nouvelle détection Frigate.\n\nCaméra : ${camera}\nObjet  : ${label}\nID     : ${EVENT_ID}\n\nPayload brut :\n${payload}"

   if [[ -n "$ATTACH" && -f "$ATTACH" ]]; then
       echo -e "$body" | mail -s "$subject" -a "$ATTACH" "$MAIL_TO"
       log "Mail envoyé avec pièce jointe : $ATTACH"
       # si tmp file, on peut le supprimer
       if [[ "$ATTACH" == /tmp/frigate_snapshot_* ]]; then
           rm -f "$ATTACH"
       fi
   else
       echo -e "$body" | mail -s "$subject" "$MAIL_TO"
       log "Mail envoyé sans pièce jointe."
   fi

done

on va créer un service systemd pour que le script soit lancé automatiquement, voilà le contenu de /usr/lib/systemd/system/frigate_alert.service

[Unit]
Description=Frigate MQTT Alert Email Service
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/alerte_frigate
Restart=always
RestartSec=5
User=root
Environment=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

[Install]
WantedBy=multi-user.target

 [Retour haut de la page]

on l'active en tapant

systemctl enable frigate_alert

et on lance via la commande

systemctl start frigate_alert

on pense à relancer Frigate car on a touché à sa configuration

docker stop frigate
docker start frigate

voilà ce que renvoie journalctl

déc. 07 12:20:43 ultra.kervao.fr systemd[1]: Started frigate_alert.service.
déc. 07 12:20:43 ultra.kervao.fr mosquitto[1436264]: 1765106443: New connection from 127.0.0.1:55164 on port 1883.
déc. 07 12:20:43 ultra.kervao.fr mosquitto[1436264]: 1765106443: New client connected from 127.0.0.1:55164 as auto-5B7917FC-A109-8461-E38C-B893A8928EA6 (p2, c1, k60, u'olivier').

et pour une détection

déc. 07 19:47:55 ultra.kervao.fr alerte_frigate[1596716]: [INFO] Detected: camera=Camera-entree, label=person, id=1765133275.303314-xxsfrt
déc. 07 19:47:59 ultra.kervao.fr alerte_frigate[1596716]: [DEBUG] Trouvé après 3 seconde(s): /media/frigate/clips/Camera-entree-1765133275.303314-xxsfrt.jpg
déc. 07 19:47:59 ultra.kervao.fr alerte_frigate[1596716]: [INFO] Clip annoté trouvé: /media/frigate/clips/Camera-entree-1765133275.303314-xxsfrt.jpg
déc. 07 19:47:59 ultra.kervao.fr alerte_frigate[1596716]: [INFO] Clip candidate trouvé: /media/frigate/clips/Camera-entree-1765133275.303314-xxsfrt.jpg
déc. 07 19:48:00 ultra.kervao.fr alerte_frigate[1596716]: [INFO] Fichier stable (taille=223910). Prêt à être envoyé.

Le contenu du mail est le suivant en cas d'alerte

Nouvelle détection Frigate.

Caméra : Camera-entree
Objet  : person
ID     : 1765133275.303314-xxsfrt

Payload brut :
{"before": {"id": "1765133275.303314-xxsfrt", "camera": "Camera-entree", "frame_time": 1765133275.303314, "snapshot": null, "label": "person", "sub_label": null, "top_score": 0.0, "false_positive": true, "start_time": 1765133275.303314, "end_time": null, "score": 0.89453125, "box": [832, 201, 907, 368], "area": 12525, "ratio": 0.4491017964071856, "region": [724, 143, 1044, 463], "active": true, "stationary": false, "motionless_count": 0, "position_changes": 0, "current_zones": [], "entered_zones": [], "has_clip": false, "has_snapshot": false, "attributes": {}, "current_attributes": [], "pending_loitering": false, "max_severity": null, "current_estimated_speed": 0, "average_estimated_speed": 0, "velocity_angle": 0, "path_data": [], "recognized_license_plate": null}, "after": {"id": "1765133275.303314-xxsfrt", "camera": "Camera-entree", "frame_time": 1765133275.499867, "snapshot": {"frame_time": 1765133275.303314, "box": [832, 201, 907, 368], "area": 12525, "region": [724, 143, 1044, 463], "score": 0.89453125, "attributes": [], "current_estimated_speed": 0, "velocity_angle": 0, "path_data": [], "recognized_license_plate": null, "recognized_license_plate_score": null}, "label": "person", "sub_label": null, "top_score": 0.8671875, "false_positive": false, "start_time": 1765133275.303314, "end_time": null, "score": 0.84765625, "box": [815, 201, 897, 364], "area": 13366, "ratio": 0.5030674846625767, "region": [716, 134, 1036, 454], "active": true, "stationary": false, "motionless_count": 0, "position_changes": 1, "current_zones": [], "entered_zones": [], "has_clip": false, "has_snapshot": true, "attributes": {}, "current_attributes": [], "pending_loitering": false, "max_severity": null, "current_estimated_speed": 0, "average_estimated_speed": 0, "velocity_angle": 0, "path_data": [[[0.6687, 0.5056], 1765133275.499867]], "recognized_license_plate": null}, "type": "new"}

avec l'image de l'instantanée en pièce jointe. Et voilà une autre variante avec un envoi avec un mail en HTML dans le corps du message

   ### --- MAIL HTML ---
   TMPMAIL=$(mktemp)
   cat > "$TMPMAIL" <<EOF
<html>
<body style="font-family:Arial,sans-serif">
<h2 style="color:#c00">🚨 Alerte Frigate</h2>
<p>
<b>Caméra :</b> ${camera}<br>
<b>Objet détecté :</b> ${label}<br>
<b>ID événement :</b> ${EVENT_ID}<br>
<b>Date :</b> $(date +"%Y-%m-%d %H:%M:%S")
</p>
<p>Snapshot annoté :</p>
</body>
</html>
EOF

   s-nail \
     -S smtp="$SMTP_URL" \
     -S from="$MAIL_FROM" \
     -s "Alerte Frigate — ${label} (${camera})" \
     -a "$ATTACH" \
     -M "text/html" \
     "$MAIL_TO" < "$TMPMAIL"

   log "Mail envoyé avec snapshot : $CLIP_FILE"
   rm -f "$TMPMAIL"

 [Retour haut de la page]

Envoi des alertes avec Signal

On en vient à Signal ou plutôt signal-cli la version en ligne de commande dont l'URL est https://github.comAsamK/signal-cli, j'ai récupéré le binaire que j'ai décompressé et placé au bon endroit

tar xvfz signal-cli-0.13.22-Linux-native.tar.gz
mv signal-cli /usr/local/bin

on aura besoin aussi du générateur qrencode qu'on installera via urpmi. On suppose maintenant que vous disponsez déjà d'un compte Signal, on va lier le poste Frigate au compte principal qui est sur le mobile en tapant

signal-cli link -n "FrigateAlert"

cela donne quelque chose comme
 
sgnl://linkdevice?uuid=17dgwYBh(...)G4GGmFEZDA%3D%3D&pub_key=BTR9CHVvtKrEmw7D(...)7r31bIG%2ByFmxv3O7q4nagj

sans trop tarder il faut taper dans un autre shell

echo "sgnl://linkdevice?uuid=17dgwYBh(...)G4GGmFEZDA%3D%3D&pub_key=BTR9CHVvtKrEmw7D(...)7r31bIG%2ByFmxv3O7q4nagj" | qrencode -t ANSIUTF8

voilà le résultat

█████████████████████████████████████████████████
█████████████████████████████████████████████████
████ ▄▄▄▄▄ █▀▄█▀   ▀  ▄▄█▄ █▀ ▄▀ ▄▀▄ █ ▄▄▄▄▄ ████
████ █   █ █▀▄  ▀▄▀  ▄▄█ ▄▀ ▀▀▄▀█▀▀  █ █   █ ████
████ █▄▄▄█ █▀  ▄▀▄█ ▀█▄█▀▄▀█▀▄▄▀▄███ █ █▄▄▄█ ████
████▄▄▄▄▄▄▄█▄▀ █▄█ ▀▄█▄█▄▀▄▀ █ ▀▄█▄▀ █▄▄▄▄▄▄▄████
████   ▄ █▄ ▄▀▄ █▄▀▄▀ ▄█▀▀▄▀▄▀ █▄▄█ ▄ ▀ ▀  ▀▀████
████  ▀ █ ▄██ ▀█▀█▀▄▄█▄▀▄▀▀▀▄██  █▄█ ▄▄▀█▀▄▀▀████
████▄█▄▀▀ ▄▄▄ ▄▄▄▀▀▀▀█▄█▀█  ▀▄▀▄▀▄██▀▀█▄▀█   ████
█████▀▀ ██▄▀▄▄█ ▄█ █▀▄▄ ▀  ██▄█▄▄███ ▄ ▀ █▄█▀████
█████▀ ▄██▄▄▀▄  ▄▀▄█▀▀▀ ▄▀▀▀▄ ▀▄ ▄▀▀▀▀▀▀▀  ▀█████
████  ██ ▄█▄ █ ██ ▄▄  ▀█  ▄█ █▀▄▀█▄▀▄██▄▄██ █████
█████▄    ▄▀ ▄▀▄▀█▄▀▄█▀█▄ █   ▄▄   ▀ █▀▄▀▄▄ ▀████
████▄▀▀ ▄▀▄▀▀ ▄█▀▄█ ▄█▀█▄▀██▄█▀▄▄█▄▀ ▀█▀▀ ██▀████
████▀  █ ▀▄█▀▄██▄█   ▄ ▀█▄ ▀█  ▀▀▄▀▀▀▀▀▀▀█ ▄▀████
████ █ ██ ▄▀▄▀▄▀▄█▀▄██▄█▄▀█▀ █▀ ████▄▀█▀▄█▄ ▀████
████ ██ ▄█▄▄▄▀▄█▄▀▀ ▀█▄█▀ █ ▄█ █▀▄▄  ▀▀▀ ▀▄█ ████
████ █▀█▄█▄ ▀▄▄ ▄▄██▀▄▀ ▀  ▀ ▄▀▄ █▀▀▄██▄█ ▄██████
████▄█▄▄▄█▄▄▀▀▄ ▄▀▄█▀ █▄ ▄ ▄▄▄▄▄▀▄▄▄ ▄▄▄ ▀ ▀ ████
████ ▄▄▄▄▄ █▄▀██▄ ▄   ▀█▀█▄█▀█▀ ▄▄   █▄█ ▄▄▀▀████
████ █   █ █ ▀█▄▀▀▄ ▄█▀█▄▄▄▀▄▀ █▄▀▀█ ▄▄▄▄█   ████
████ █▄▄▄█ █ █▀█▀█  ▄█ █▄▀█▀█▄ ▄███▄▀▀▄ ▄ ▄▀█████
████▄▄▄▄▄▄▄█▄▄██▄█▄▄▄▄███▄▄█▄▄▄▄███▄███▄█████████
█████████████████████████████████████████████████
█████████████████████████████████████████████████
avec le mobile on associe le poste Frigate en visualisant le QRCode ainsi obtenu et dans le premier shell on a comme message

INFO  ProvisioningManagerImpl - Received link information from +336XXXXXXXX, linking in progress ...
Associated with: +336XXXXXXXX

C'est bon le serveur Frigate est bien associé au compte Signal principal

Pour voir si ça fonctionne on peut taper

signal-cli --username +336XXXXXXXX send -m "This is a message" 06YYYYYYYY

  [Retour haut de la page]

maintenant on pourra rajouter au script

### --- ENVOI SIGNAL ---
   SIGNAL_USER="+336XXXXXXXX"       # ton numéro Signal
   SIGNAL_DEST="+336YYYYYYYY"       # numéro qui reçoit les alertes qui peut être le même numéro, ça apparaitra dans les Notes perso

   signal-cli \
      send -u "$SIGNAL_USER"\
      -a "$ATTACH"\
      -m "🚨 Alerte Frigate
      Caméra : ${camera}
      Objet  : ${label}
      ID     : ${EVENT_ID}
      Date   : $(date)" \
      "$SIGNAL_DEST"

  log "Alerte envoyée par Signal à $SIGNAL_DEST"a

Et voilà ce que ça donne avec un envoi sur mon propre numéro

en cas d'alerte qui ne correspond pas à person ou car voilà ce que journalctl remontera

déc. 12 18:39:10 ultra.kervao.fr alerte_frigate[3356635]: [DEBUG] Événement ignoré pour label=cat

Voilà une variante pour envoyer sur un groupe spécifique où on pourra rajouter d'autres personnes. Pour lister les groupes on tapera

signal-cli listGroups 

voilà le résultat

INFO  AccountHelper - The Signal protocol expects that incoming messages are regularly received.
Id: 2BVGj6gu1es4K9(...)4BdAwavlpon8rE= Name: groupe1  Active: true Blocked: false
Id: vToJsVzeJeME(...)iyP+Xxf61plZA8= Name: groupe2  Active: true Blocked: false
Id: ZWLvp3vW(....)vYy5hse3hpTQ0= Name: groupe3  Active: true Blocked: false
Id: 9dhS9vM5(...)rVVUJSM/7jYIrIU84= Name: groupe4  Active: true Blocked: false
Id: puoaoo7(...)8hm62WWcMlFqo= Name: groupe5  Active: true Blocked: false

et on met l'id du groupe concerné, pour envoyer un message ça donnera

signal-cli --username +336XXXXXXXX send -g vToJsVzeJeME(...)iyP+Xxf61plZA8=  -m "This is a test message"

et on pourra adapter le script en conséquence.

[retour haut de la page]

Frigate+

Maintenant on clique sur Explorer et dans les filtres, on retient que les objets qui ont un instantané (snapshot) et qui n'ont pas été encore soumis à la base centralisée de Frigate+

on clique sur une image d'un objet et puis sur Instantané, on confirme si l'objet détecté en bas à droite de l'image est bien identifé

L'image est soumis au serveur centralisé et ainsi de suite, on se rend maintenant sous https://plus.frigate.video/dashboard/images/?tab=0 où on retrouve toutes les images qui ont été soumises. En cliquant sur une image on retrouve les objets qui ont été détectés

Si on est d'accord, on clique sur Verify & Save

Maintenant si un objet n'a pas été détecté on peut lui indiquer en cliquant sur Add (w) et on place la boîte de détection à l'endroit qui va bien en identifiant clairement l'objet (dans l'image ci-dessous il n'y a personne, c'est pour l'illustration)

a fortiori s'il y a un faux positif, on cliquera sur la boîte pour la supprimer et on voit que le label de l'objet se retrouve barré

On va maintenant générer son modèle personnalisé en plus du modèle de base de Frigate+ qui est lui même enrichi et entraîné par les objets identifiés par la communauté. Pour le créer il faut télécharger au moins dix images qui auront été correctement annotés et vérifiés, puis on l'enrichit en continuant à télécharger des images. L'idéal est d'avoir une bonne centaine d'images dans toutes les configurations météo pour les caméras extérieures et de luminosité.
On peut créer jusqu'à 12 modèles dans l'année basés sur des modèles de base différents, je me suis contenté d'un seul modèle personnalisé que j'ai créé en cliquant sur Request Model

J'ai choisi mobiledet qui correspond à ma clé TPU

Et voilà le résultat

L'onglet Base Models donne la liste des modèles de base utilisés par défaut

et on relance Frigate pour que le fichier soit pris en compte, et voilà ce que ça donne dans l'interface

A partir de là il faudra modifier les réglages de détection conformément à cette page. Ensuite on peut constater qu'on capte bien plus d'objets comme ce chat que je n'arrivais pas à détecter auparavant

En cas de non reconduction de l'abonnement on pourra toujours avoir accès au modèle personnalisé.

Quelques liens pour en savoir plus

• https://docs.frigate.video/integrations/plus/
• https://docs.frigate.video/plus/first_model
• https://docs.frigate.video/plus/annotating/#false-positive-labels
• https://www.reddit.com/r/frigate_nvr/comments/1n4cqlz/frigate_labeling_false_positives_what_is_correct/?tl=fr