Créez un système de vidéosurveillance intelligent avec le Raspberry Pi 5

Vous voulez garder un œil sur votre maison, votre bureau ou votre jardin sans vous ruiner en caméras propriétaires ou abonnements cloud ? Avec le Raspberry Pi 5, construisez un système de vidéosurveillance intelligent qui filme en haute définition, détecte les mouvements, reconnaît les visages, capte les sons suspects, et vous alerte en temps réel sur votre smartphone. Ce projet open-source exploite la puissance du Pi 5 pour une solution professionnelle, abordable et entièrement personnalisable. Prêt à sécuriser votre espace façon DIY ? C’est parti !

Le Raspberry Pi 5, avec son processeur quad-core Cortex-A76 à 2,4 GHz et son GPU VideoCore VII, est taillé pour les tâches vidéo et audio exigeantes, comme le streaming 4K ou l’analyse d’images en temps réel.

Voici pourquoi ce projet est un must :

Intelligent : Détection de mouvements, reconnaissance faciale, et analyse audio.
Économique : Moins cher que les caméras commerciales, sans frais récurrents.
Polyvalent : Intégration avec la domotique, vision nocturne, ou multi-caméras.
Éducatif : Apprenez à manipuler caméras, OpenCV, et notifications automatisées.

Matériel nécessaire

Voici les composants nécessaires pour ce système :

Raspberry Pi 5 (4 Go pour la base, 8 Go pour la reconnaissance faciale ou multi-caméras).
Carte microSD (64 Go minimum, classe 10, SanDisk ou Samsung pour la fiabilité).
Caméra :
- Caméra Raspberry Pi HQ (12,3 Mpx, idéale pour la HD) avec objectif grand-angle (ex. : 6 mm).
- Ou webcam USB avec micro intégré (ex. : Logitech C920 ou C922, qui inclut un microphone stéréo pour la détection audio).
Boîtier avec ventilation active (ex. : GeeekPi ou Flirc, car le traitement vidéo/audio chauffe).
Alimentation USB-C (5.1V/5A, officielle pour une stabilité optimale).
Câble ribbon (pour la caméra HQ) ou câble USB (pour webcam).
Optionnel :
- SSD NVMe (via HAT PCIe) pour un stockage rapide et durable.
- Capteur infrarouge PIR (ex. : HC-SR501) pour déclencher l’enregistrement.
- LED infrarouge (850 nm) pour la vision nocturne.
- Boîtier étanche pour une installation extérieure.
Coût estimé : 120-180 € (configuration de base), 200-250 € avec SSD et accessoires avancés.

Prérequis

Ce projet suppose que votre Raspberry Pi 5 est configuré avec Raspberry Pi OS 64-bit (Desktop ou Lite). Assurez-vous que :

Le système est à jour :bash
```
sudo apt update && sudo apt upgrade -y
```
SSH est activé pour un accès à distance (via raspi-config > Interface Options > SSH).
La caméra est activée pour la caméra Raspberry Pi HQ (via raspi-config > Interface Options > Camera).
Pour une webcam USB comme la Logitech C920/C922, elle est détectée automatiquement, y compris son microphone intégré.

Note : La Logitech C920/C922 inclut un microphone stéréo de qualité, éliminant le besoin d’un micro USB séparé pour la détection audio.

Étapes de réalisation

Ce guide détaille la création d’un système de vidéosurveillance avec streaming en direct, détection de mouvement, reconnaissance faciale, détection audio via le micro de la webcam, notifications, et vision nocturne. Chaque étape est conçue pour un résultat optimal.

Étape 1 : Connecter et tester la caméra

Branchez la caméra :
- Caméra Raspberry Pi HQ : Connectez-la au port CSI avec le câble ribbon (Pi éteint). Assurez-vous que l’objectif est bien fixé.
- Webcam USB (Logitech C920/C922) : Branchez-la sur un port USB 3.0.
Testez la caméra :
- Pour la caméra HQ :bash
```
libcamera-still -o test.jpg
```
  Vérifiez test.jpg pour confirmer la qualité.
- Pour la webcam USB :bash
```
sudo apt install fswebcam fswebcam test.jpg
```
  Si des erreurs surviennent, vérifiez avec :
  
  bash
```
dmesg | grep usb
```
Testez le microphone intégré (pour Logitech C920/C922) :
- Vérifiez que le micro est détecté :bash
```
arecord -l
```
  Vous devriez voir la webcam listée (ex. : hw:1,0).
- Enregistrez un son de test :bash
```
arecord -D hw:1,0 -f cd test.wav -d 5 aplay test.wav
```
  Cela enregistre 5 secondes et les lit. Ajustez hw:1,0 selon votre configuration.
Ajustez les paramètres (optionnel) :
- Pour la caméra HQ, testez le streaming vidéo :bash
```
libcamera-vid -t 10000 -o test.h264 --width 1920 --height 1080
```
- Pour la webcam, vérifiez la résolution supportée :bash
```
v4l2loopback-ctl list
```

Étape 2 : Installer MotionEye pour la vidéosurveillance

MotionEye est un logiciel open-source qui gère le streaming, l’enregistrement, et la détection de mouvement.

Installez les dépendances :bash

sudo apt install python3-pip python3-dev libssl-dev libcurl4-openssl-dev libjpeg-dev ffmpeg

Installez MotionEye :bash
```
pip3 install motioneye
```

Configurez MotionEye comme service :

Créez un dossier de configuration :bash

sudo mkdir -p /etc/motioneye sudo cp /usr/local/share/motioneye/extra/motioneye.conf.sample /etc/motioneye/motioneye.conf

Activez et démarrez le service :bash

sudo systemctl enable motioneye sudo systemctl start motioneye

Accédez à l’interface :
- Ouvrez http://<IP_du_Pi>:8765 dans un navigateur.
- Connectez-vous avec l’utilisateur admin (pas de mot de passe par défaut). Changez le mot de passe immédiatement (Settings > General).
Ajoutez la caméra :
- Cliquez sur « Add Camera ».
- Sélectionnez :
  - « Libcamera » pour la caméra Raspberry Pi HQ.
  - « Local V4L2 Camera » pour la Logitech C920/C922.
- Réglez la résolution (ex. : 1920×1080 pour HD) et le framerate (15-20 fps pour équilibrer qualité et charge CPU).
- Activez l’audio si vous utilisez la webcam (Settings > Audio Stream).

Étape 3 : Configurer la détection de mouvement

Activer la détection :
- Dans MotionEye, allez dans les paramètres de la caméra.
- Cochez « Motion Detection » et ajustez :
  - Sensibilité : 10-20 % pour éviter les faux positifs (ex. : feuilles, ombres).
  - Zone de détection : Tracez une zone ciblée (ex. : entrée principale).
- Activez « Movies » pour enregistrer des clips lors des détections.
Configurer le stockage :
- Définissez un dossier pour les enregistrements (ex. : /home/pi/videos).
- Si vous utilisez un SSD NVMe :
  - Connectez-le via un HAT PCIe.
  - Montez-le dans /etc/fstab (ex. : /mnt/ssd).
  - Pointez MotionEye vers ce dossier.
- Supprimez automatiquement les fichiers anciens :bash
```
crontab -e
```
  Ajoutez :
  
  bash
```
0 0 * * * find /mnt/ssd/videos -type f -mtime +7 -delete
```

Ajouter un capteur PIR (optionnel) :

Connectez un capteur PIR aux GPIO (ex. : GPIO 18 pour le signal, 5V, GND).

Script Python pour déclencher MotionEye :python

import RPi.GPIO as GPIO import subprocess import time PIR_PIN = 18 GPIO.setmode(GPIO.BCM) GPIO.setup(PIR_PIN, GPIO.IN) while True:     if GPIO.input(PIR_PIN):         subprocess.run(["curl", "-X", "POST", "http://<IP_du_Pi>:8765/api/1/detection/start"])         time.sleep(10)     else:         subprocess.run(["curl", "-X", "POST", "http://<IP_du_Pi>:8765/api/1/detection/pause"])     time.sleep(0.1)

Installez la bibliothèque :bash
```
pip3 install RPi.GPIO
```
Lancez en arrière-plan :bash
```
python3 pir_trigger.py &
```

Étape 4 : Ajouter l’intelligence avec OpenCV

Pour une surveillance intelligente, utilisez OpenCV pour la reconnaissance faciale.

Installez OpenCV :bash
```
pip3 install opencv-python numpy
```

Téléchargez un modèle de détection faciale :bash

wget https://raw.githubusercontent.com/opencv/opencv/master/data/haarcascades/haarcascade_frontalface_default.xml

Script de reconnaissance faciale :

Ce script détecte les visages, enregistre les images, et trace un rectangle :python

import cv2 import datetime face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml') # Pour Logitech C920/C922 cap = cv2.VideoCapture(0) cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280) cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720) while True:     ret, frame = cap.read()     if not ret:         print("Erreur de capture")         break     gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)     faces = face_cascade.detectMultiScale(gray, scaleFactor=1.3, minNeighbors=5)     for (x, y, w, h) in faces:         cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)         timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")         filename = f"face_{timestamp}.jpg"         cv2.imwrite(filename, frame)         print(f"Visage détecté : {filename}")     cv2.imshow('Frame', frame)     if cv2.waitKey(1) & 0xFF == ord('q'):         break cap.release() cv2.destroyAllWindows()

Pour la caméra HQ, utilisez un pipeline libcamera :python

cap = cv2.VideoCapture('libcamerasrc ! video/x-raw, width=1280, height=720 ! videoconvert ! appsink')

Reconnaissance de visages connus (avancé) :

Installez face_recognition :bash
```
pip3 install face_recognition
```
Créez une base de visages connus (ex. : known_faces/person1.jpg).

Script pour identifier les visages :python

import face_recognition import cv2 known_image = face_recognition.load_image_file("known_faces/person1.jpg") known_encoding = face_recognition.face_encodings(known_image)[0] cap = cv2.VideoCapture(0) while True:     ret, frame = cap.read()     if not ret:         break     rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)     face_locations = face_recognition.face_locations(rgb_frame)     face_encodings = face_recognition.face_encodings(rgb_frame, face_locations)     for face_encoding in face_encodings:         match = face_recognition.compare_faces([known_encoding], face_encoding)         name = "Inconnu"         if match[0]:             name = "Personne connue"         print(f"Visage : {name}")     cv2.imshow('Frame', frame)     if cv2.waitKey(1) & 0xFF == ord('q'):         break cap.release() cv2.destroyAllWindows()

Intégrez à MotionEye via « Run a Command ».

Étape 5 : Configurer les notifications

Notifications Telegram :

Créez un bot avec BotFather pour obtenir un token.
Trouvez votre chat ID via https://api.telegram.org/bot<VOTRE_TOKEN>/getUpdates.
Installez la bibliothèque :bash
```
pip3 install python-telegram-bot
```

Ajoutez des alertes au script OpenCV :python

from telegram import Bot import asyncio async def send_alert(image_path):     bot = Bot(token='VOTRE_TOKEN')     await bot.send_message(chat_id='VOTRE_CHAT_ID', text='⚠️ Visage détecté !')     await bot.send_photo(chat_id='VOTRE_CHAT_ID', photo=open(image_path, 'rb')) # Dans le script OpenCV if faces:     timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")     filename = f"face_{timestamp}.jpg"     cv2.imwrite(filename, frame)     asyncio.run(send_alert(filename))

Notifications par e-mail :
- Dans MotionEye, configurez les e-mails (Settings > Email Notifications) avec un serveur SMTP (ex. : Gmail, port 587, clé d’application).
- Activez l’envoi d’images ou de liens vers les clips.

Notifications push :

Utilisez Pushover :bash

pip3 install python-pushover

python

from pushover import Client client = Client("VOTRE_USER_KEY", api_token="VOTRE_API_TOKEN") client.send_message("Mouvement détecté !", title="Alerte Surveillance")

Étape 6 : Détection audio avec le micro intégré

La Logitech C920/C922 intègre un micro stéréo, parfait pour détecter des sons suspects (ex. : verre brisé, aboiements).

Vérifiez le micro :bash
```
arecord -l
```
Notez l’identifiant (ex. : hw:1,0).
Installez les bibliothèques audio :bash
```
pip3 install sounddevice numpy
```

Script de détection audio :python

import sounddevice as sd import numpy as np import subprocess THRESHOLD = 0.05  # Ajuster selon l'environnement def audio_callback(indata, frames, time, status):     volume_norm = np.linalg.norm(indata) * 10     if volume_norm > THRESHOLD:         print("Son détecté !")         subprocess.run(["curl", "-X", "POST", "http://<IP_du_Pi>:8765/api/1/detection/start"]) stream = sd.InputStream(device="hw:1,0", callback=audio_callback) with stream:     while True:         sd.sleep(1000)

Intégration avec MotionEye :
- Configurez une action pour enregistrer si un son est détecté.
- Ajustez THRESHOLD pour éviter les déclenchements par des bruits ambiants (ex. : ventilation).

Étape 7 : Ajouter la vision nocturne

Installer des LED infrarouges :
- Connectez un module IR (850 nm) aux GPIO via un transistor MOSFET (ex. : IRF520) :
  - GPIO 17 pour le contrôle.
  - 5V pour l’alimentation.
  - GND commun.
- Script pour activer les LED la nuit :python
```
import RPi.GPIO as GPIO import time IR_PIN = 17 GPIO.setmode(GPIO.BCM) GPIO.setup(IR_PIN, GPIO.OUT) while True:     GPIO.output(IR_PIN, GPIO.HIGH)  # Allumer LED IR     time.sleep(3600)  # Actif 1h     GPIO.output(IR_PIN, GPIO.LOW)  # Éteindre     time.sleep(3600)
```
- Pour une activation intelligente, ajoutez un capteur de luminosité (ex. : TSL2561).
Optimiser la caméra :
- Pour la caméra HQ, retirez le filtre IR (démontage délicat) pour une meilleure sensibilité.
- La Logitech C920/C922 fonctionne bien en faible luminosité, mais bénéficie des LED IR.

Temps estimé

Base (MotionEye + détection de mouvement) : 2 heures.
Reconnaissance faciale (OpenCV) : +1 heure.
Notifications (Telegram/e-mail) : +1 heure.
Détection audio et vision nocturne : +1 à 2 heures.

Résultat final

Votre Raspberry Pi 5 devient un système de vidéosurveillance intelligent :

Streaming en direct : Accessible via navigateur ou smartphone (MotionEye).
Détection de mouvement : Enregistrements automatiques, renforcés par un capteur PIR.
Reconnaissance faciale : Alertes pour visages connus/inconnus via OpenCV.
Détection audio : Réaction aux sons suspects grâce au micro intégré de la Logitech C920/C922.
Notifications : Telegram, e-mails, ou push avec photos/clips.
Vision nocturne : Surveillance 24/7 avec LED infrarouges.

Le Pi 5 gère le streaming 4K, l’analyse d’images, l’audio, et les notifications simultanément, grâce à sa puissance et ses ports USB 3.0.

Conseils pour optimiser

Gestion thermique : Le traitement vidéo/audio chauffe le Pi 5. Utilisez un ventilateur actif et vérifiez :bash
```
vcgencmd measure_temp
```
Si >70°C, réduisez la résolution ou ajoutez un dissipateur.
Sécurité réseau : Sécurisez MotionEye avec un mot de passe fort et un pare-feu :bash
```
sudo apt install ufw sudo ufw allow 8765 sudo ufw enable
```
Pour un accès externe, configurez une redirection de port (8765) et un DNS dynamique (ex. : DuckDNS).
Performances : Pour plusieurs caméras ou OpenCV intensif, utilisez 8 Go de RAM et un SSD NVMe.
Qualité audio : Ajustez le gain du micro de la Logitech C920/C922 avec alsamixer pour optimiser la détection.
Sauvegardes : Sauvegardez vos scripts et configurations MotionEye sur un disque externe ou Git.

Idées pour aller plus loin

Domotique : Intégrez à Home Assistant pour déclencher des lumières ou sirènes lors d’une détection.
Multi-caméras : Ajoutez des Raspberry Pi Zero 2 W comme caméras secondaires, gérées par le Pi 5.
IA avancée : Utilisez TensorFlow Lite pour détecter des objets (ex. : voitures, animaux) ou entraîner un modèle pour reconnaître vos animaux de compagnie.

Cloud : Synchronisez les enregistrements sur Google Drive ou Nextcloud :python

from pydrive.auth import GoogleAuth from pydrive.drive import GoogleDrive gauth = GoogleAuth() drive = GoogleDrive(gauth) file = drive.CreateFile({'title': 'video.mp4'}) file.SetContentFile('/mnt/ssd/videos/video.mp4') file.Upload()

Analyse comportementale : Implémentez une détection de trajectoire avec OpenCV pour signaler des mouvements anormaux.
Interface mobile : Créez une appli web avec Flask pour visualiser les flux et gérer les alertes.

Notes techniques et ressources

Sources : Documentation Raspberry Pi (caméra, GPIO), MotionEye (GitHub), OpenCV (site officiel), et inspirations de Hackster.io, adaptées pour un projet original.
Compatibilité : La Logitech C920/C922 est UVC, donc plug-and-play. Pour la caméra HQ avec OpenCV, un pipeline libcamera peut être nécessaire.
Dépannage : Vérifiez les logs MotionEye (/var/log/motioneye.log) ou dmesg pour les erreurs. Testez le micro avec alsamixer si la détection audio est faible.

Conclusion

Avec ce système de vidéosurveillance intelligent, le Raspberry Pi 5 prouve qu’il peut rivaliser avec des solutions professionnelles tout en restant accessible et flexible. Grâce à la Logitech C920/C922 et son micro intégré, vous ajoutez une détection audio sans matériel supplémentaire, rendant le projet encore plus compact. Que vous protégiez votre maison, surveilliez un atelier, ou observiez un coin de nature, ce système DIY est une belle démonstration des possibilités du Pi 5. Partagez vos astuces ou vos variantes sur black-lab.fr, et continuez à explorer le monde du faire-soi-même !