Objets Connectés et Internet des Objets (IoT)

# Simulation d'architecture IoT
# Communication entre capteurs, passerelle et cloud

import time
import random
import json
from datetime import datetime

class CapteurIoT:
    """Simule un capteur IoT (température/humidité)"""

    def __init__(self, id_capteur, type_capteur, localisation):
        self.id = id_capteur
        self.type = type_capteur
        self.localisation = localisation
        self.batterie = 100
        self.connecte = False

    def lire_donnees(self):
        """Lit les données du capteur"""
        # Simuler les mesures
        if self.type == "temperature":
            valeur = 20 + random.gauss(0, 2)
            unite = "°C"
        elif self.type == "humidite":
            valeur = 50 + random.gauss(0, 10)
            unite = "%"
        elif self.type == "luminosite":
            valeur = random.randint(0, 1000)
            unite = "lux"
        else:
            valeur = random.random() * 100
            unite = ""

        # Consommer de la batterie
        self.batterie = max(0, self.batterie - 0.1)

        return {
            "device_id": self.id,
            "type": self.type,
            "value": round(valeur, 2),
            "unit": unite,
            "location": self.localisation,
            "battery": round(self.batterie, 1),
            "timestamp": datetime.now().isoformat()
        }

    def envoyer_message(self, message):
        """Simule l'envoi d'un message (D2C)"""
        if self.connecte and self.batterie > 0:
            print(f"  [{self.id}] → Message envoyé: {message['type']}={message['value']}{message['unit']}")
            return True
        return False

class PasserelleIoT:
    """Passerelle/Gateway qui collecte les données des capteurs"""

    def __init__(self, nom):
        self.nom = nom
        self.capteurs = []
        self.buffer_messages = []
        self.connecte_cloud = False

    def enregistrer_capteur(self, capteur):
        """Enregistre un capteur sur la passerelle"""
        self.capteurs.append(capteur)
        capteur.connecte = True
        print(f"[Gateway {self.nom}] Capteur {capteur.id} enregistré")

    def collecter_donnees(self):
        """Collecte les données de tous les capteurs"""
        donnees = []
        for capteur in self.capteurs:
            if capteur.batterie > 0:
                data = capteur.lire_donnees()
                capteur.envoyer_message(data)
                donnees.append(data)
        self.buffer_messages.extend(donnees)
        return donnees

    def synchroniser_cloud(self, cloud):
        """Envoie les données au cloud"""
        if self.buffer_messages:
            print(f"\n[Gateway {self.nom}] Synchronisation cloud...")
            print(f"  → Envoi de {len(self.buffer_messages)} messages")
            cloud.recevoir_donnees(self.buffer_messages)
            self.buffer_messages = []
            return True
        return False

class CloudIoT:
    """Simule un service cloud IoT"""

    def __init__(self, nom):
        self.nom = nom
        self.base_donnees = []
        self.regles_alertes = []
        self.abonnes = []

    def recevoir_donnees(self, donnees):
        """Reçoit et stocke les données"""
        for d in donnees:
            self.base_donnees.append(d)
            print(f"  [Cloud] Reçu: {d['device_id']} - {d['type']}={d['value']}")

            # Vérifier les règles d'alerte
            self.verifier_alertes(d)

    def ajouter_regle_alerte(self, type_capteur, condition, seuil, message):
        """Ajoute une règle d'alerte"""
        self.regles_alertes.append({
            'type': type_capteur,
            'condition': condition,
            'seuil': seuil,
            'message': message
        })

    def verifier_alertes(self, donnee):
        """Vérifie les conditions d'alerte"""
        for regle in self.regles_alertes:
            if donnee['type'] == regle['type']:
                declenchee = False
                if regle['condition'] == '>' and donnee['value'] > regle['seuil']:
                    declenchee = True
                elif regle['condition'] == '<' and donnee['value'] < regle['seuil']:
                    declenchee = True

                if declenchee:
                    print(f"  🚨 ALERTE: {regle['message']} ({donnee['value']}{donnee['unit']})")
                    self.notifier_abonnes(regle['message'], donnee)

    def abonner(self, callback):
        """Abonne un utilisateur aux notifications"""
        self.abonnes.append(callback)

    def notifier_abonnes(self, message, donnee):
        """Notifie tous les abonnés"""
        for callback in self.abonnes:
            callback(message, donnee)

    def statistiques(self):
        """Calcule des statistiques sur les données"""
        stats = {}
        for d in self.base_donnees:
            key = d['type']
            if key not in stats:
                stats[key] = {'values': [], 'count': 0}
            stats[key]['values'].append(d['value'])
            stats[key]['count'] += 1

        print("\n📊 STATISTIQUES CLOUD")
        print("-" * 40)
        for type_c, data in stats.items():
            moy = sum(data['values']) / len(data['values'])
            mini = min(data['values'])
            maxi = max(data['values'])
            print(f"  {type_c}: {data['count']} mesures")
            print(f"    Min={mini:.1f} | Moy={moy:.1f} | Max={maxi:.1f}")

# ================================================================
# SIMULATION COMPLÈTE
# ================================================================

print("="*60)
print("   SIMULATION ARCHITECTURE IoT COMPLÈTE")
print("="*60)

# Créer le cloud
cloud = CloudIoT("MonCloud")

# Ajouter des règles d'alerte
cloud.ajouter_regle_alerte("temperature", ">", 25, "Température élevée!")
cloud.ajouter_regle_alerte("temperature", "<", 15, "Température basse!")
cloud.ajouter_regle_alerte("humidite", ">", 70, "Humidité élevée!")

# Abonner un utilisateur
def notification_utilisateur(message, donnee):
    print(f"  📱 [Notification] {message}")

cloud.abonner(notification_utilisateur)

# Créer la passerelle
gateway = PasserelleIoT("GW_Maison")

# Créer les capteurs
print("\n📡 ENREGISTREMENT DES CAPTEURS")
print("-" * 40)

capteurs = [
    CapteurIoT("TEMP_SALON", "temperature", "Salon"),
    CapteurIoT("TEMP_CHAMBRE", "temperature", "Chambre"),
    CapteurIoT("HUM_SDB", "humidite", "Salle de bain"),
    CapteurIoT("LUM_JARDIN", "luminosite", "Jardin"),
]

for c in capteurs:
    gateway.enregistrer_capteur(c)

# Simuler plusieurs cycles de collecte
print("\n🔄 CYCLES DE COLLECTE")
print("-" * 40)

for cycle in range(3):
    print(f"\n--- Cycle {cycle + 1} ---")
    gateway.collecter_donnees()
    gateway.synchroniser_cloud(cloud)
    time.sleep(0.1)

# Afficher les statistiques
cloud.statistiques()

# État des batteries
print("\n🔋 ÉTAT DES BATTERIES")
print("-" * 40)
for c in capteurs:
    symbole = "🟢" if c.batterie > 50 else "🟡" if c.batterie > 20 else "🔴"
    print(f"  {symbole} {c.id}: {c.batterie:.1f}%")

print("\n" + "="*60)