Créez un système de surveillance pour animaux avec Raspberry Pi

Le Raspberry Pi est un ordinateur monocarte polyvalent qui, associé à des composants appropriés, peut être transformé en un système de surveillance intelligent pour animaux. Ce guide détaillé vous accompagnera pas à pas dans la création d’un tel système, intégrant la détection de mouvement, la reconnaissance d’animaux et l’envoi de notifications.

Vue d’ensemble du projet

Le projet permet de créer une solution de surveillance avancée pour animaux, capable de :

Détecter les mouvements à l’aide de la caméra.
Identifier les animaux via l’intelligence artificielle (IA).
Envoyer des notifications personnalisées par e-mail incluant des images et le type d’animal détecté.
Gérer les paramètres de configuration (types d’animaux, e-mail, alertes) via une interface web.

Matériel requis

Raspberry Pi 4 (ou modèle supérieur)
Caméra pour Raspberry Pi (module caméra officiel ou webcam USB compatible)
Carte microSD (32 Go minimum) avec Raspberry Pi OS
Clavier, souris et écran pour la configuration initiale
Connexion internet (Wi-Fi ou Ethernet pour l’interface web)

Étape 1 : Installation et configuration initiale du Raspberry Pi

Installer Raspberry Pi OS sur votre carte microSD en utilisant Raspberry Pi Imager.
Démarrer et configurer le Raspberry Pi (réseau, date, langue).
Mettre à jour le système :

sudo apt update && sudo apt upgrade -y

Étape 2 : Préparer la caméra et installer les bibliothèques d’IA

2.1 Activer et tester la caméra

Activez la caméra :

sudo raspi-config

Tester la caméra :

raspistill -o test.jpg

2.2 Installer OpenCV et TensorFlow Lite

Installer OpenCV pour la détection d’image :

sudo apt install python3-opencv -y

Télécharger et configurer le modèle MobileNet SSD pour la reconnaissance d’animaux :

mkdir ~/models && cd ~/models
wget https://storage.googleapis.com/download.tensorflow.org/models/tflite/coco_ssd_mobilenet_v1_1.0_quant_2018_06_29.zip
unzip coco_ssd_mobilenet_v1_1.0_quant_2018_06_29.zip

Étape 3 : Détection de mouvements et reconnaissance des animaux

Nous allons créer un script Python pour analyser les images et détecter les animaux.

Créez un fichier animal_surveillance.py :

nano animal_surveillance.py

Ajoutez le code suivant pour configurer la détection de mouvement, la capture d’images, et la reconnaissance des animaux :

import cv2
import tensorflow as tf
import numpy as np
from datetime import datetime
import os

# Charger le modèle TensorFlow Lite
interpreter = tf.lite.Interpreter(model_path="~/models/detect.tflite")
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Définir les classes d'animaux détectables
ANIMAL_CLASSES = {16: "Oiseau", 17: "Chat", 18: "Chien"}
DETECTION_THRESHOLD = 0.5

# Initialiser la caméra
camera = cv2.VideoCapture(0)
first_frame = None

# Fonction pour détecter les animaux
def detect_animal(frame):
    input_shape = input_details[0]['shape']
    frame_resized = cv2.resize(frame, (input_shape[1], input_shape[2]))
    input_data = np.expand_dims(frame_resized, axis=0)
    interpreter.set_tensor(input_details[0]['index'], input_data)
    interpreter.invoke()
    boxes = interpreter.get_tensor(output_details[0]['index'])[0]
    classes = interpreter.get_tensor(output_details[1]['index'])[0]
    scores = interpreter.get_tensor(output_details[2]['index'])[0]
    for i in range(len(scores)):
        if scores[i] >= DETECTION_THRESHOLD:
            return ANIMAL_CLASSES.get(int(classes[i]), "Inconnu")
    return None

# Fonction pour détecter les mouvements
def detect_motion():
    global first_frame
    ret, frame = camera.read()
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    gray = cv2.GaussianBlur(gray, (21, 21), 0)

    if first_frame is None:
        first_frame = gray
        return None

    delta_frame = cv2.absdiff(first_frame, gray)
    thresh_frame = cv2.threshold(delta_frame, 25, 255, cv2.THRESH_BINARY)[1]
    thresh_frame = cv2.dilate(thresh_frame, None, iterations=2)
    contours, _ = cv2.findContours(thresh_frame.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    for contour in contours:
        if cv2.contourArea(contour) < 5000:
            continue
        animal = detect_animal(frame)
        if animal:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            image_path = f"/home/pi/captures/{animal}_{timestamp}.jpg"
            cv2.imwrite(image_path, frame)
            return animal, image_path
    return None, None

if __name__ == "__main__":
    os.makedirs("/home/pi/captures", exist_ok=True)
    print("Surveillance animale en cours...")
    while True:
        animal, image_path = detect_motion()
        if animal:
            print(f"Animal détecté : {animal}")
            # Notifications et alertes peuvent être ajoutées ici

Le script détecte le mouvement, reconnaît les animaux, et enregistre une capture d’image pour chaque détection.

Étape 4 : Interface Web avec Flask pour configurer les paramètres et afficher les captures

Pour une gestion plus facile, nous allons créer une interface web permettant de configurer les paramètres d’alerte et de visualiser les images capturées.

4.1 Installation de Flask

pip3 install flask

4.2 Création du Serveur Flask

Créer un fichier app.py pour l’interface :

nano app.py

Ajouter le code Flask suivant pour configurer l’interface web :

from flask import Flask, render_template, request, redirect, url_for
import os

app = Flask(__name__)

# Stockage des paramètres
config = {
    "email": "destination_email@example.com",
    "animals": ["Chat", "Chien"]
}

@app.route("/")
def index():
    captures = os.listdir("/home/pi/captures/")
    captures = [f"/static/captures/{capture}" for capture in captures]
    return render_template("index.html", config=config, captures=captures)

@app.route("/settings", methods=["POST"])
def settings():
    config["email"] = request.form["email"]
    config["animals"] = request.form.getlist("animals")
    return redirect(url_for("index"))

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

Créer le modèle HTML index.html pour gérer la configuration et visualiser les captures :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Surveillance Animale</title>
</head>
<body>
    <h1>Configuration de Surveillance Animale</h1>
    <form action="/settings" method="post">
        <label for="email">E-mail de Notification :</label>
        <input type="email" name="email" value="{{ config.email }}" required><br>
        <label>Animaux Suivis :</label><br>
        <input type="checkbox" name="animals" value="Chat" {% if "Chat" in config.animals %}checked{% endif %}> Chat<br>
        <input type="checkbox" name="animals" value="Chien" {% if "Chien" in config.animals %}checked{% endif %}> Chien<br>
        <button type="submit">Enregistrer</button>
    </form>
    <h2>Captures :</h2>
    {% for capture in captures %}
        <img src="{{ capture }}" width="300"><br>
    {% endfor %}
</body>
</html>

Démarrer le serveur Flask :

python3 app.py

Accédez à l’interface via http://<adresse_ip_du_raspberry_pi>:5000.

Étape 5 : Configuration des notifications e-mail avec captures et détails d’animaux

5.1 Installation et configuration de l’envoi d’e-mails

Pour envoyer des notifications, nous utiliserons smtplib, une bibliothèque Python standard pour envoyer des e-mails via un serveur SMTP (par exemple, Gmail).

Créer un fichier de configuration pour stocker vos informations de connexion e-mail de manière sécurisée.

Créez un fichier config.py

nano config.py

Ajoutez les informations de connexion suivantes (en remplaçant par votre adresse et mot de passe) :

EMAIL_ADDRESS = "votre_email@gmail.com"
EMAIL_PASSWORD = "votre_mot_de_passe"

Sauvegardez et fermez le fichier.

Activer l’accès aux applications moins sécurisées dans votre compte Google (si vous utilisez Gmail), car smtplib nécessite une autorisation pour accéder à votre compte via SMTP.

5.2 Ajouter la fonction d’envoi d’e-mails dans le script de surveillance

Modifiez animal_surveillance.py pour inclure la fonction d’envoi d’e-mails, intégrant l’image capturée et le type d’animal détecté

Ouvrez animal_surveillance.py et ajoutez la fonction suivante pour l’envoi des e-mails :

import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.image import MIMEImage
import config  # Importer le fichier config pour récupérer l'email et le mot de passe

def send_email_alert(image_path, detected_animal):
    # Créer un e-mail
    msg = MIMEMultipart()
    msg['From'] = config.EMAIL_ADDRESS
    msg['To'] = config.EMAIL_ADDRESS  # Envoyer à vous-même ou à l’adresse spécifiée dans config
    msg['Subject'] = f"Alerte : {detected_animal} détecté !"

    # Ajouter le corps du message
    body = f"Un {detected_animal} a été détecté par le système de surveillance animale."
    msg.attach(MIMEText(body, 'plain'))

    # Ajouter l'image en pièce jointe
    with open(image_path, 'rb') as f:
        img_data = f.read()
        image = MIMEImage(img_data, name=os.path.basename(image_path))
        msg.attach(image)

    # Envoi de l'e-mail via SMTP
    try:
        server = smtplib.SMTP('smtp.gmail.com', 587)
        server.starttls()
        server.login(config.EMAIL_ADDRESS, config.EMAIL_PASSWORD)
        server.sendmail(config.EMAIL_ADDRESS, config.EMAIL_ADDRESS, msg.as_string())
        server.quit()
        print("E-mail envoyé avec succès.")
    except Exception as e:
        print(f"Erreur lors de l'envoi de l'e-mail : {e}")

Intégrer la fonction d’envoi d’e-mails dans le script de détection :

Modifiez la partie if animal: dans detect_motion() pour envoyer un e-mail avec les détails de l’animal détecté.

if animal:
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    image_path = f"/home/pi/captures/{animal}_{timestamp}.jpg"
    cv2.imwrite(image_path, frame)
    print(f"{animal} détecté. Image sauvegardée : {image_path}")
    send_email_alert(image_path, animal)  # Appel de la fonction d'envoi d'e-mail

Sauvegardez et fermez le fichier animal_surveillance.py.

Tester le script en exécutant :

python3 animal_surveillance.py

Lorsque le système détecte un mouvement et reconnaît un animal, il envoie un e-mail à l’adresse configurée avec l’image de l’animal détecté et le type d’animal dans le sujet de l’e-mail.

Conclusion

Ce guide fournit un système de surveillance animal intelligent complet utilisant le Raspberry Pi. Grâce à la détection de mouvement, la reconnaissance d’animaux, une interface web de configuration et des notifications e-mail détaillées, ce projet est une solution puissante et flexible pour surveiller vos animaux. Vous pouvez facilement personnaliser les paramètres d’alerte et ajouter de nouveaux types d’animaux via la configuration web.

Raspberry Pi 5

Raspberry Pi PICO

Goodies

Raspberry Pi 4

Raspberry Pi Compute Module

Manettes

Raspberry Pi 3 & Pi 2

Nos kits Raspberry Pi

Écrans

Raspberry Pi Zero

Solutions Industrielles