┌─────────────────────────────────────────────────────────────┐
  │                    SYSTÈME DE SURVEILLANCE                   │
  └─────────────────────────────────────────────────────────────┘

  ┌───────────────────┐    USB Série     ┌────────────────────┐
  │   ARDUINO UNO     │ ══════════════>  │  RASPBERRY PI ZERO │
  │                   │   (9600 bauds)   │                    │
  │  Capteur PIR ─→ D2│                  │  ┌──────────────┐  │
  │  LED alarme ←─ D13│  "MOUVEMENT"     │  │  Caméra 5MP  │  │
  │                   │  ─────────────→  │  │  (CSI port)  │  │
  │  Détecte les      │                  │  └──────────────┘  │
  │  mouvements et    │  "OK"            │                    │
  │  envoie l'alerte  │  <─────────────  │  Python :          │
  │                   │                  │  - picamera2       │
  │                   │                  │  - pyserial        │
  │                   │                  │  - datetime        │
  └───────────────────┘                  └────────────────────┘
          │                                       │
          │  Capteur PIR HC-SR501                  │ Caméra CSI
          │  ┌─────────────┐                      │ ┌──────┐
          └──│  ◉ PIR      │                      └─│ 📷   │
             │  détection  │                        │      │
             │  5m portée  │                        └──────┘
             └─────────────┘

  Flux :
  1. PIR détecte un mouvement → Arduino envoie "MOUVEMENTn"
  2. Pi reçoit via série → Python capture une photo horodatée
  3. Photo sauvegardée dans /home/pi/surveillance/
  4. Pi renvoie "OKn" → Arduino éteint la LED après 5s

    Capteur PIR HC-SR501              Arduino Uno R3
   ┌──────────────────┐            ┌─────────────────┐
   │  ┌────────────┐  │            │                 │
   │  │  ◉ Lentille│  │            │                 │
   │  │  Fresnel   │  │            │                 │
   │  └────────────┘  │            │                 │
   │                  │            │                 │
   │  VCC  OUT  GND   │            │                 │
   └──┼────┼────┼─────┘            │                 │
      │    │    │                  │                 │
      │    │    └─────────────────→│ GND             │
      │    └──────────────────────→│ D2 (interrupt)  │
      └───────────────────────────→│ 5V              │
                                   │                 │
                                   │ D13 ──[220Ω]──→ LED
                                   │                 │
                                   │ USB ════════════│═→ Raspberry Pi
                                   └─────────────────┘

// =============================================
// Système de Surveillance — Arduino (Capteurs)
// Communication série avec Raspberry Pi
// Tutoriel didactico.tn
// =============================================

const int brochePIR = 2;     // Sortie du capteur PIR
const int brocheLED = 13;    // LED d'alarme

bool mouvementDetecte = false;
unsigned long dernierMouvement = 0;
const unsigned long DELAI_RELANCE = 5000;  // 5s entre 2 alertes
int compteurAlertes = 0;

void setup() {
  Serial.begin(9600);
  pinMode(brochePIR, INPUT);
  pinMode(brocheLED, OUTPUT);

  Serial.println("SURVEILLANCE_ARDUINO_PRET");

  // Le PIR a besoin de 30-60s pour se calibrer
  Serial.println("CALIBRATION_PIR");
  delay(30000);  // Attendre 30 secondes
  Serial.println("SYSTEME_ACTIF");

void loop() {
  int etatPIR = digitalRead(brochePIR);
  unsigned long maintenant = millis();

  // --- Mouvement détecté ---
  if (etatPIR == HIGH && (maintenant - dernierMouvement > DELAI_RELANCE)) {
    dernierMouvement = maintenant;
    compteurAlertes++;

    // Allumer la LED d'alarme
    digitalWrite(brocheLED, HIGH);

    // Envoyer l'alerte au Raspberry Pi via série
    Serial.print("MOUVEMENT:");
    Serial.println(compteurAlertes);

  // --- Vérifier les commandes du Pi ---
  if (Serial.available()) {
    String commande = Serial.readStringUntil('n');
    commande.trim();

    if (commande == "PHOTO_OK") {
      // Le Pi a pris la photo, éteindre la LED
      digitalWrite(brocheLED, LOW);

    else if (commande == "STATUS") {
      // Le Pi demande l'état
      Serial.print("ALERTES:");
      Serial.print(compteurAlertes);
      Serial.print(":PIR:");
      Serial.println(etatPIR);

delay(100);  // Petit délai pour stabilité

#!/usr/bin/env python3
# =============================================
# Système de Surveillance — Raspberry Pi
# Caméra + communication série avec Arduino
# Tutoriel didactico.tn
# =============================================

import serial
import time
import os
from datetime import datetime

# Essayer picamera2 (Raspberry Pi OS Bookworm+)
try:
    from picamera2 import Picamera2
    PICAMERA2 = True
except ImportError:
    print("[AVERTISSEMENT] picamera2 non disponible.")
    print("Installer : sudo apt install python3-picamera2")
    PICAMERA2 = False

# --- Configuration ---
PORT_SERIE = "/dev/ttyACM0"    # Port USB de l'Arduino (ou /dev/ttyUSB0)
VITESSE = 9600                 # Même vitesse que l'Arduino
DOSSIER_PHOTOS = "/home/pi/surveillance"

# Créer le dossier de stockage des photos
os.makedirs(DOSSIER_PHOTOS, exist_ok=True)

def initialiser_camera():
    """Initialiser la caméra Pi avec picamera2."""
    if not PICAMERA2:
        return None

    camera = Picamera2()

    # Configuration pour les captures photo
    config = camera.create_still_configuration(
        main={"size": (2592, 1944)},  # Résolution max 5MP
        lores={"size": (640, 480)},
        display="lores"
    )
    camera.configure(config)
    camera.start()
    time.sleep(2)  # Laisser la caméra s'ajuster

    print("[OK] Caméra 5MP initialisée")
    return camera

def capturer_photo(camera, numero_alerte):
    """Capturer une photo horodatée."""
    horodatage = datetime.now().strftime("%Y%m%d_%H%M%S")
    nom_fichier = f"alerte_{numero_alerte:04d}_{horodatage}.jpg"
    chemin = os.path.join(DOSSIER_PHOTOS, nom_fichier)

    if camera:
        camera.capture_file(chemin)
        taille = os.path.getsize(chemin) // 1024
        print(f"[PHOTO] {nom_fichier} ({taille} Ko)")
    else:
        # Mode simulation sans caméra
        with open(chemin, "w") as f:
            f.write("simulation")
        print(f"[SIMULATION] {nom_fichier}")

    return chemin

def main():
    print("╔═══════════════════════════════════════════╗")
    print("║  Surveillance Pi + Arduino — didactico.tn ║")
    print("╚═══════════════════════════════════════════╝")

    # --- Initialiser la caméra ---
    camera = initialiser_camera()

    # --- Connexion série vers Arduino ---
    print(f"[...] Connexion série : {PORT_SERIE}")
    try:
        arduino = serial.Serial(PORT_SERIE, VITESSE, timeout=1)
        time.sleep(2)  # Attendre le reset Arduino
        print("[OK] Arduino connecté")
    except serial.SerialException as e:
        print(f"[ERREUR] Port série : {e}")
        print("Vérifier : ls /dev/ttyACM* /dev/ttyUSB*")
        return

    print(f"[OK] Photos → {DOSSIER_PHOTOS}")
    print("[...] En attente de mouvements...n")

    photos_total = 0

    try:
        while True:
            # --- Lire les messages de l'Arduino ---
            if arduino.in_waiting > 0:
                ligne = arduino.readline().decode("utf-8").strip()

                if ligne.startswith("MOUVEMENT:"):
                    # Extraire le numéro d'alerte
                    num = ligne.split(":")[1]
                    heure = datetime.now().strftime("%H:%M:%S")

                    print(f"⚠️  [{heure}] MOUVEMENT détecté ! (alerte #{num})")

                    # Capturer la photo
                    chemin = capturer_photo(camera, int(num))
                    photos_total += 1

                    # Confirmer à l'Arduino
                    arduino.write(b"PHOTO_OKn")
                    print(f"    Total photos : {photos_total}n")

                elif ligne.startswith("CALIBRATION"):
                    print("[...] Calibration du capteur PIR (30s)...")

                elif ligne.startswith("SYSTEME_ACTIF"):
                    print("[OK] Système de surveillance ACTIF !n")

                else:
                    print(f"[Arduino] {ligne}")

            time.sleep(0.1)

    except KeyboardInterrupt:
        print(f"n[FIN] Surveillance arrêtée. {photos_total} photos capturées.")
    finally:
        if camera:
            camera.stop()
        arduino.close()

if __name__ == "__main__":
    main()

sudo apt update
sudo apt install python3-picamera2 python3-serial
# Activer la caméra : sudo raspi-config → Interface → Camera → Enable
# Lancer : python3 surveillance_pi.py

╔═══════════════════════════════════════════╗
║  Surveillance Pi + Arduino — didactico.tn ║
╚═══════════════════════════════════════════╝
[OK] Caméra 5MP initialisée
[...] Connexion série : /dev/ttyACM0
[OK] Arduino connecté
[OK] Photos → /home/pi/surveillance
[...] Calibration du capteur PIR (30s)...
[OK] Système de surveillance ACTIF !

[...] En attente de mouvements...

⚠️  [14:23:15] MOUVEMENT détecté ! (alerte #1)
[PHOTO] alerte_0001_20260405_142315.jpg (1842 Ko)
    Total photos : 1

⚠️  [14:23:47] MOUVEMENT détecté ! (alerte #2)
[PHOTO] alerte_0002_20260405_142347.jpg (1756 Ko)
    Total photos : 2

Où acheter un Raspberry Pi avec caméra en Tunisie ?

Peut-on utiliser ce système de surveillance la nuit en Tunisie ?

Quel est le meilleur projet de surveillance Arduino pour les étudiants en Tunisie ?