#!/usr/bin/env python3

# Import de la bibliothèque Picamera2 pour contrôler les caméras Raspberry Pi
from picamera2 import Picamera2

# Fonction permettant de mettre le programme en pause
from time import sleep

# Permet de récupérer la date et l'heure actuelles
from datetime import datetime

# Permet de gérer facilement les chemins et dossiers
from pathlib import Path


# ============================================================
# DOSSIER DE SAUVEGARDE
# ============================================================

# Création du dossier "photos" s'il n'existe pas déjà
output_dir = Path("photos")
output_dir.mkdir(exist_ok=True)


# ============================================================
# HORODATAGE
# ============================================================

# Création d'un horodatage commun aux deux photos
# Format : AAAAMMJJ_HHMMSS
# Exemple : 20260918_112530
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")


# ============================================================
# CAMÉRA 0
# ============================================================

# Création de l'objet correspondant à la caméra 0
cam0 = Picamera2(0)

# Création de la configuration pour une photo fixe
#
# Résolution utilisée :
# 4608 x 2592 pixels
#
# Cette résolution correspond à la résolution souhaitée
# pour la caméra 0.
config0 = cam0.create_still_configuration(
    main={"size": (4608, 2592)}
)

# Application de la configuration à la caméra
cam0.configure(config0)

# Démarrage de la caméra
cam0.start()

# Petite attente afin de laisser la caméra s'initialiser
# et stabiliser l'image avant la capture.
sleep(2)

# Création du nom du fichier de sortie
#
# Exemple :
# photos/camera0_20260918_112530.jpg
file0 = output_dir / f"camera0_{timestamp}.jpg"

# Affichage dans le terminal du fichier qui va être créé
print(f"Capture caméra 0 : {file0}")

# Capture d'une photo et sauvegarde directement au format JPEG
cam0.capture_file(str(file0))

# Arrêt de la caméra 0
cam0.stop()

# Libération complète des ressources utilisées par la caméra 0
#
# Cette étape est particulièrement importante ici :
# elle permet de libérer les buffers mémoire DMA avant
# de configurer la deuxième caméra.
cam0.close()


# ============================================================
# CAMÉRA 1
# ============================================================

# Création de l'objet correspondant à la caméra 1
cam1 = Picamera2(1)

# Création de la configuration pour une photo fixe
#
# Résolution utilisée :
# 3280 x 2464 pixels
#
# Cette résolution correspond à la résolution souhaitée
# pour la caméra 1.
config1 = cam1.create_still_configuration(
    main={"size": (3280, 2464)}
)

# Application de la configuration à la caméra
cam1.configure(config1)

# Démarrage de la caméra
cam1.start()

# Petite attente afin de laisser la caméra s'initialiser
# et stabiliser l'image avant la capture.
sleep(2)

# Création du nom du fichier de sortie
#
# Exemple :
# photos/camera1_20260918_112530.jpg
file1 = output_dir / f"camera1_{timestamp}.jpg"

# Affichage dans le terminal du fichier qui va être créé
print(f"Capture caméra 1 : {file1}")

# Capture d'une photo et sauvegarde directement au format JPEG
cam1.capture_file(str(file1))

# Arrêt de la caméra 1
cam1.stop()

# Libération complète des ressources utilisées par la caméra 1
cam1.close()


# ============================================================
# FIN DU PROGRAMME
# ============================================================

# Message indiquant que les deux captures sont terminées
print("Captures terminées.")

from picamera2 import Picamera2
import time

# Création de l'objet permettant de contrôler la caméra
picam2 = Picamera2()

# Création d'une configuration pour prendre une photo
config = picam2.create_still_configuration()

# Application de la configuration à la caméra
picam2.configure(config)

# Démarrage de la caméra
picam2.start()

# Attente de 2 secondes pour laisser le temps à la caméra de s'initialiser
time.sleep(2)

# Capture d'une photo et enregistrement dans le fichier "photo.jpg"
picam2.capture_file("photo.jpg")

# Arrêt de la caméra après la capture
picam2.stop()

# Affichage d'un message indiquant que la photo a été enregistrée
print("Photo enregistrée : photo.jpg")

from picamera2 import Picamera2
from picamera2.encoders import H264Encoder
from picamera2.outputs import FfmpegOutput
import time

# Création de l'objet caméra
picam2 = Picamera2()

# Configuration pour la vidéo
config = picam2.create_video_configuration()
picam2.configure(config)

# Création de l'encodeur vidéo H.264
encoder = H264Encoder()

# Création de la sortie MP4
output = FfmpegOutput("video.mp4")

# Démarrage de la caméra
picam2.start()

# Attente de l'initialisation
time.sleep(2)

# Démarrage de l'enregistrement
picam2.start_recording(encoder, output)

# Enregistrement pendant 10 secondes
time.sleep(10)

# Arrêt de l'enregistrement
picam2.stop_recording()

# Arrêt de la caméra
picam2.stop()

print("Vidéo enregistrée : video.mp4")

import subprocess # permet de lancer le programme arecord pour récupérer le son du microphone.
import numpy as np # permet de traiter les données audio et de calculer le RMS.
import MR25
import time

DEVICE = "hw:0,0"
RATE = 48000
CHANNELS = 1
CHUNK = 1024

THRESHOLD = 0.01 # le seuil sonore.

# Temps minimum entre deux frappes
DEBOUNCE_TIME = 0.20

# Temps maximum pour regrouper les frappes
GROUP_TIMEOUT = 0.80
# Le programme attend au maximum 0,8 seconde après la dernière frappe.

cmd = [
    "arecord",
    "-D", DEVICE,
    "-f", "S16_LE",
    "-r", str(RATE),
    "-c", str(CHANNELS),
    "-t", "raw",
    "-"
]

process = subprocess.Popen(
    cmd,
    stdout=subprocess.PIPE,
    stderr=subprocess.DEVNULL
)

nombre_frappes = 0
derniere_frappe = 0
dernier_signal = 0

print("Écoute du microphone...")
print("1 frappe = LED rouge")
print("3 frappes = LED verte")
print("Ctrl+C pour arrêter.\n")

try:
    while True:

        data = process.stdout.read(CHUNK * 2)

        if len(data) != CHUNK * 2:
            break

        audio = np.frombuffer(data, dtype=np.int16)
        audio = audio.astype(np.float32) / 32768.0

        volume = np.sqrt(np.mean(audio ** 2))

        maintenant = time.time()

        # Affichage du volume
        bar = min(50, int(volume * 50))

        print(
            f"\rVolume : {volume:.3f} "
            f"[{'#' * bar:<50}] "
            f"Frappes : {nombre_frappes}",
            end="",
            flush=True
        )

        # Détection d'une frappe
        if volume > THRESHOLD:

            # Évite de compter plusieurs fois la même frappe
            if maintenant - derniere_frappe > DEBOUNCE_TIME:

                nombre_frappes += 1
                derniere_frappe = maintenant

                print(f"\n>>> Frappe {nombre_frappes}")

        # Si le délai entre les frappes est dépassé,
        # on analyse le nombre de frappes
        if (
            nombre_frappes > 0
            and maintenant - derniere_frappe > GROUP_TIMEOUT
        ):

            if nombre_frappes == 1:
                print(">>> 1 FRAPPE : avancer")
                MR25.ledRGB("100")
                MR25.forward(30)
                time.sleep(0.5)
                MR25.ledRGB("000")

            elif nombre_frappes == 2:
                print(">>> 2 FRAPPES : tourner à gauche")
                MR25.ledRGB("010")
                MR25.turnLeft(30)
                time.sleep(0.5)
                MR25.ledRGB("000")

            elif nombre_frappes == 3:
                print(">>> 3 FRAPPES : tourner à droite")
                MR25.ledRGB("001")
                MR25.turnRight(30)
                time.sleep(0.5)
                MR25.ledRGB("000")

            elif nombre_frappes == 4:
                print(">>> 4 FRAPPES : STOP")
                MR25.ledRGB("111")
                MR25.stop()
                time.sleep(0.5)
                MR25.ledRGB("000")

            else:
                print(f">>> {nombre_frappes} frappes : aucune action")

            # Réinitialisation
            nombre_frappes = 0

except KeyboardInterrupt:
    print("\n\nArrêt du robot.")
    MR25.stop()

finally:
    process.terminate()