ajout de tous les cours et TP préparés cet été

Soc/CORRIGE.md

@@ -0,0 +1,263 @@
+# Corrigé des exercices — Circuits intégrés et SoC
+
+---
+
+## Exercice 1 : Loi de Moore (QCM)
+
+1. **Réponse : b)** Le nombre de transistors double environ tous les deux ans (à coût constant)
+
+2. **Réponse : d)** Toutes les réponses ci-dessus
+   - Les transistors approchent de la taille atomique
+   - L'effet tunnel quantique perturbe le fonctionnement
+   - La chaleur dégagée devient difficile à évacuer
+
+3. **Réponse : b)** Multiplier le nombre de cœurs
+   - L'augmentation de la fréquence génère trop de chaleur
+   - La multiplication des cœurs permet d'augmenter la puissance totale sans augmenter la fréquence unitaire
+
+---
+
+## Exercice 2 : Composants d'un SoC
+
+1. **Composants intégrables dans un SoC :**
+   - ✅ CPU
+   - ✅ GPU
+   - ❌ Disque dur mécanique
+   - ✅ Contrôleur Wi-Fi
+   - ✅ Mémoire cache
+   - ✅ NPU (Neural Processing Unit)
+   - ❌ Écran
+   - ✅ Contrôleur USB
+
+2. **Pourquoi un disque dur mécanique ne peut pas être intégré :**
+   - Un disque dur mécanique contient des pièces mobiles (plateaux rotatifs, têtes de lecture)
+   - Ces composants mécaniques ne peuvent pas être miniaturisés à l'échelle d'une puce
+   - La technologie est fondamentalement différente (mécanique vs électronique)
+   - Les SSD (mémoire flash) peuvent en revanche être intégrés car ils sont purement électroniques
+
+3. **Avantages et inconvénients :**
+
+   | Avantages | Inconvénients |
+   |-----------|---------------|
+   | Compacité : tout tient sur une puce | Non évolutif : impossible de remplacer un composant |
+   | Consommation réduite : moins de distance entre composants | Obsolescence : tout le système vieillit ensemble |
+   | Performance : communication ultra-rapide | Réparation difficile : panne = remplacement total |
+   | Coût de production réduit en masse | Impact environnemental : recyclage complexe |
+
+---
+
+## Exercice 3 : Calculs sur les transistors
+
+1. **Facteur multiplicatif entre Intel 4004 et Apple M1 :**
+
+   ```
+   Facteur = 16 000 000 000 / 2 300
+   Facteur = 6 956 521,7
+   Facteur ≈ 7 millions
+   ```
+
+   Le nombre de transistors a été multiplié par environ **7 millions** en 49 ans.
+
+2. **Calcul théorique selon la loi de Moore :**
+
+   Entre 1971 et 2020, il y a 49 ans, soit 49/2 = 24,5 doublements.
+
+   ```
+   Transistors théoriques = 2 300 × 2^24,5
+   Transistors théoriques = 2 300 × 23 726 566
+   Transistors théoriques ≈ 54,6 milliards
+   ```
+
+3. **Comparaison :**
+
+   - Valeur théorique : ~54,6 milliards de transistors
+   - Valeur réelle (Apple M1) : 16 milliards de transistors
+
+   L'Apple M1 a **moins** de transistors que prévu par la loi de Moore pure. Cependant, la loi de Moore a été globalement respectée jusqu'aux années 2010, puis le rythme a légèrement ralenti. De plus, l'Apple M3 (2023) atteint 37 milliards, montrant que la progression continue.
+
+---
+
+## Exercice 4 : ARM vs x86
+
+| Critère | Architecture x86 | Architecture ARM |
+|---------|------------------|------------------|
+| Type d'instructions | CISC | **RISC** |
+| Consommation électrique | **Élevée** | Faible |
+| Utilisation principale | **PC, serveurs** | Smartphones, tablettes |
+| Exemples de fabricants | Intel, AMD | **Apple, Qualcomm, ARM Ltd** |
+| Complexité des instructions | Élevée | **Faible** |
+
+---
+
+## Exercice 5 : Systèmes embarqués
+
+### 1. Thermostat connecté
+
+| Élément | Description |
+|---------|-------------|
+| **Capteurs** | Température (thermistance), humidité, présence (infrarouge) |
+| **Contraintes** | Faible consommation (fonctionnement sur batterie ou alimentation continue), connectivité Wi-Fi stable |
+| **SoC possible** | ESP32 (Wi-Fi + Bluetooth intégrés, faible coût) |
+
+### 2. Système ABS d'une voiture
+
+| Élément | Description |
+|---------|-------------|
+| **Capteurs** | Capteurs de vitesse de roue (effet Hall), accéléromètres |
+| **Contraintes** | Temps réel strict (réaction en millisecondes), fiabilité critique (sécurité), résistance aux vibrations et températures |
+| **SoC possible** | Microcontrôleur automobile certifié (ex: Infineon AURIX, NXP S32) |
+
+### 3. Montre connectée (smartwatch)
+
+| Élément | Description |
+|---------|-------------|
+| **Capteurs** | Accéléromètre, gyroscope, cardiofréquencemètre optique, GPS |
+| **Contraintes** | Ultra-faible consommation (autonomie de plusieurs jours), miniaturisation extrême, connectivité Bluetooth |
+| **SoC possible** | Qualcomm Snapdragon Wear, Apple S9 |
+
+---
+
+## Exercice 6 : Impact environnemental
+
+### 1. Trois problèmes environnementaux liés à la fabrication des SoC :
+
+1. **Extraction des terres rares** : mines polluantes, déforestation, contamination des sols et des eaux
+2. **Consommation d'eau** : les usines de fabrication (fabs) utilisent des millions de litres d'eau ultra-pure par jour
+3. **Consommation énergétique** : la fabrication d'une puce de quelques grammes nécessite plusieurs kWh d'énergie
+
+### 2. Pourquoi les SoC contribuent à l'obsolescence programmée :
+
+- **Non évolutivité** : impossible de remplacer uniquement le GPU ou d'ajouter de la RAM
+- **Fin des mises à jour** : les fabricants cessent de supporter les anciens SoC après quelques années
+- **Incompatibilité logicielle** : les nouvelles applications nécessitent des fonctionnalités absentes des anciens SoC
+- **Batterie soudée** : souvent associée à un SoC, rendant le remplacement difficile
+
+### 3. Trois actions concrètes pour réduire l'impact :
+
+1. **Allonger la durée de vie** : utiliser ses appareils le plus longtemps possible, faire réparer plutôt que remplacer
+2. **Acheter reconditionné** : donner une seconde vie aux appareils
+3. **Recycler correctement** : déposer les appareils en fin de vie dans les points de collecte dédiés (pas à la poubelle)
+
+---
+
+## Exercice 7 : Analyse d'un SoC réel
+
+### 1. Pourquoi des cœurs à différentes fréquences ?
+
+Architecture **big.LITTLE** (ou hétérogène) :
+- **Cœurs performants** (3.3 GHz) : pour les tâches exigeantes (jeux, montage vidéo)
+- **Cœurs efficients** (2.3 GHz) : pour les tâches légères (veille, notifications)
+
+Avantages :
+- Meilleure autonomie : les tâches simples utilisent les cœurs économes
+- Puissance disponible : les cœurs performants interviennent quand nécessaire
+
+### 2. Rôle du NPU :
+
+Le **NPU** (Neural Processing Unit) est optimisé pour les calculs d'intelligence artificielle :
+- Reconnaissance faciale et vocale
+- Amélioration des photos (mode nuit, flou d'arrière-plan)
+- Traduction en temps réel
+- Suggestions de texte prédictif
+
+Il est plus efficace que le CPU/GPU pour ces tâches spécifiques.
+
+### 3. Avantage du modem 5G intégré :
+
+- **Consommation réduite** : moins de distance entre le modem et le CPU = moins d'énergie
+- **Latence réduite** : communication plus rapide entre composants
+- **Compacité** : gain de place sur la carte mère
+- **Coût** : moins de composants à assembler
+
+### 4. Rapport de fréquence :
+
+```
+Rapport = 3.3 GHz / 2.3 GHz
+Rapport = 1,43
+```
+
+Le cœur le plus rapide est **1,43 fois** plus rapide que le cœur le plus lent (soit 43% de plus).
+
+---
+
+## Exercice 8 : RISC-V et open source
+
+### 1. Définition "open source" pour une architecture :
+
+- Les **spécifications** de l'architecture sont publiques et libres d'utilisation
+- N'importe qui peut concevoir un processeur RISC-V sans payer de licence
+- Contrairement à ARM (licence payante) ou x86 (propriétaire Intel/AMD)
+
+### 2. Deux avantages de RISC-V :
+
+1. **Pas de royalties** : économie sur les coûts de licence
+2. **Personnalisation** : possibilité d'ajouter des instructions spécifiques à ses besoins
+
+### 3. Domaine adapté :
+
+- **IoT et objets connectés** : coût très faible par unité
+- **Recherche et éducation** : possibilité d'étudier et modifier l'architecture
+- **Systèmes embarqués spécialisés** : personnalisation pour des tâches précises
+
+### 4. Intérêt des grandes entreprises :
+
+- **Indépendance** : ne pas dépendre d'ARM ou Intel
+- **Réduction des coûts** : pas de licence à payer sur des millions d'unités
+- **Souveraineté technologique** : certains pays (Chine) veulent des alternatives aux technologies occidentales
+- **Innovation** : liberté de créer des designs optimisés pour leurs besoins spécifiques
+
+---
+
+## Exercice 9 : Conversion et calculs
+
+### 1. Conversions de 3 nm :
+
+```
+3 nm = 3 × 10⁻⁹ m
+
+En micromètres :
+3 nm = 0,003 µm = 3 × 10⁻³ µm
+
+En mètres :
+3 nm = 0,000000003 m = 3 × 10⁻⁹ m
+```
+
+### 2. Nombre d'atomes de silicium :
+
+```
+Diamètre d'un atome de Si ≈ 0,2 nm
+
+Nombre d'atomes = 3 nm / 0,2 nm = 15 atomes
+```
+
+Environ **15 atomes** de silicium peuvent tenir sur une largeur de 3 nm.
+
+### 3. Limites de la miniaturisation :
+
+- Avec seulement 15 atomes, le contrôle des électrons devient très difficile
+- L'**effet tunnel quantique** permet aux électrons de "traverser" les barrières
+- Les fluctuations statistiques (un atome de plus ou de moins) ont un impact significatif
+- La chaleur générée par unité de surface devient extrême
+- On approche des **limites fondamentales de la physique**
+
+---
+
+## Exercice 10 : Synthèse
+
+**Exemple de rédaction :**
+
+Les systèmes sur puce (SoC) ont révolutionné l'informatique mobile en permettant d'intégrer tous les composants essentiels d'un ordinateur sur une seule puce de silicium. Cette intégration offre des avantages majeurs : une compacité remarquable permettant de créer des smartphones toujours plus fins, une consommation énergétique réduite grâce à la proximité des composants, et des performances accrues par une communication ultra-rapide entre le CPU, le GPU et la mémoire.
+
+Les architectures ARM, avec leur philosophie RISC, ont particulièrement contribué à cette révolution en proposant un excellent rapport performance/consommation. Les récents processeurs Apple Silicon démontrent que ces architectures peuvent désormais rivaliser avec les processeurs x86 traditionnels, même sur ordinateur.
+
+Cependant, l'avenir des SoC fait face à des défis importants. La miniaturisation approche ses limites physiques : avec des transistors de 3 nm (environ 15 atomes), les effets quantiques perturbent le fonctionnement normal des circuits. Les fabricants doivent explorer de nouvelles pistes comme l'empilement 3D, les nouveaux matériaux, ou les architectures hétérogènes.
+
+Enfin, l'impact environnemental devient une préoccupation majeure. La fabrication des SoC nécessite des ressources rares et beaucoup d'énergie, tandis que leur nature non évolutive contribue à l'obsolescence programmée. L'industrie devra concilier innovation technologique et responsabilité écologique pour un avenir durable.
+
+---
+
+Auteur : Florian Mathieu
+
+Licence CC BY NC
+
+<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.

Soc/Corrige_TP_Station_Meteo_IoT.py

@@ -0,0 +1,537 @@
+"""
+Corrigé du TP Station Météo IoT — Simulation d'un système embarqué
+"""
+
+import random
+import time
+import json
+import math
+
+
+# =============================================================================
+# PARTIE 1 : Simulation des capteurs
+# =============================================================================
+
+class Capteur:
+    """Simule un capteur embarqué sur SoC."""
+
+    def __init__(self, nom, unite, val_min, val_max, precision=1):
+        """
+        Initialise un capteur.
+
+        :param nom: (str) Nom du capteur
+        :param unite: (str) Unité de mesure
+        :param val_min: (float) Valeur minimale possible
+        :param val_max: (float) Valeur maximale possible
+        :param precision: (int) Nombre de décimales
+        """
+        self.nom = nom
+        self.unite = unite
+        self.val_min = val_min
+        self.val_max = val_max
+        self.precision = precision
+        self._derniere_valeur = None
+
+    def lire(self):
+        """
+        Simule une lecture du capteur.
+        Retourne une valeur réaliste (proche de la précédente).
+
+        :return: (float) Valeur mesurée
+        """
+        if self._derniere_valeur is None:
+            # Première lecture : valeur aléatoire dans la plage
+            valeur = random.uniform(self.val_min, self.val_max)
+        else:
+            # Lectures suivantes : variation réaliste (±10% de la plage)
+            amplitude = (self.val_max - self.val_min) * 0.1
+            variation = random.uniform(-amplitude, amplitude)
+            valeur = self._derniere_valeur + variation
+
+        # S'assurer que la valeur reste dans les limites
+        valeur = max(self.val_min, min(self.val_max, valeur))
+
+        # Arrondir selon la précision
+        valeur = round(valeur, self.precision)
+
+        self._derniere_valeur = valeur
+        return valeur
+
+    def __repr__(self):
+        return f"Capteur({self.nom}, {self.unite})"
+
+
+# =============================================================================
+# PARTIE 2 : Buffer circulaire
+# =============================================================================
+
+class BufferCirculaire:
+    """
+    Buffer circulaire pour stocker les dernières mesures.
+    Mémoire fixe, adapté aux systèmes embarqués.
+    """
+
+    def __init__(self, taille):
+        """
+        Initialise le buffer.
+
+        :param taille: (int) Nombre maximum d'éléments
+        """
+        self.taille = taille
+        self.donnees = [None] * taille  # Pré-allocation
+        self.index = 0
+        self.compte = 0
+
+    def ajouter(self, valeur):
+        """
+        Ajoute une valeur au buffer.
+        Écrase la plus ancienne si plein.
+
+        :param valeur: La valeur à ajouter
+        """
+        self.donnees[self.index] = valeur
+        self.index = (self.index + 1) % self.taille
+
+        if self.compte < self.taille:
+            self.compte += 1
+
+    def moyenne(self):
+        """
+        Calcule la moyenne des valeurs stockées.
+
+        :return: (float) Moyenne ou None si vide
+        """
+        if self.compte == 0:
+            return None
+
+        total = sum(self.donnees[i] for i in range(self.compte))
+        return total / self.compte
+
+    def min_max(self):
+        """
+        Retourne le minimum et le maximum.
+
+        :return: (tuple) (min, max) ou (None, None) si vide
+        """
+        if self.compte == 0:
+            return (None, None)
+
+        valeurs = [self.donnees[i] for i in range(self.compte)]
+        return (min(valeurs), max(valeurs))
+
+    def ecart_type(self):
+        """
+        Calcule l'écart-type des valeurs stockées.
+
+        :return: (float) Écart-type ou None si vide
+        """
+        if self.compte < 2:
+            return None
+
+        moy = self.moyenne()
+        variance = sum((self.donnees[i] - moy) ** 2 for i in range(self.compte)) / self.compte
+        return math.sqrt(variance)
+
+    def valeurs(self):
+        """Retourne la liste des valeurs stockées."""
+        return [self.donnees[i] for i in range(self.compte)]
+
+    def est_plein(self):
+        """Vérifie si le buffer est plein."""
+        return self.compte >= self.taille
+
+    def __len__(self):
+        return self.compte
+
+
+# =============================================================================
+# PARTIE 3 : Station météo complète
+# =============================================================================
+
+class StationMeteo:
+    """
+    Station météo IoT simulant un système sur SoC.
+    """
+
+    # Constantes de consommation (en mW)
+    CONSO_VEILLE = 0.5
+    CONSO_MESURE = 10
+    CONSO_ENVOI = 50
+    CONSO_CALCUL = 5
+
+    def __init__(self, nom, taille_buffer=10):
+        """
+        Initialise la station.
+
+        :param nom: (str) Identifiant de la station
+        :param taille_buffer: (int) Taille des buffers de données
+        """
+        self.nom = nom
+
+        # Capteurs
+        self.capteurs = {
+            'temperature': Capteur("Température", "°C", -20, 50, 1),
+            'humidite': Capteur("Humidité", "%", 0, 100, 0),
+            'pression': Capteur("Pression", "hPa", 950, 1050, 1)
+        }
+
+        # Buffers pour chaque capteur
+        self.buffers = {
+            nom: BufferCirculaire(taille_buffer)
+            for nom in self.capteurs
+        }
+
+        # Compteur de mesures
+        self.nb_mesures = 0
+
+        # Mode économie d'énergie
+        self.mode_eco = False
+
+        # Consommation énergétique
+        self.energie_totale = 0  # mWh consommés
+
+        # Buffer d'envoi pour mode éco
+        self.buffer_envoi = []
+
+    def _consommer(self, activite, duree_ms):
+        """
+        Enregistre la consommation d'énergie.
+
+        :param activite: (str) Type d'activité
+        :param duree_ms: (int) Durée en millisecondes
+        """
+        conso = {
+            'veille': self.CONSO_VEILLE,
+            'mesure': self.CONSO_MESURE,
+            'envoi': self.CONSO_ENVOI,
+            'calcul': self.CONSO_CALCUL
+        }
+        # Convertir en mWh : mW * (ms / 3600000)
+        self.energie_totale += conso.get(activite, 1) * (duree_ms / 3600000)
+
+    def mesurer(self):
+        """
+        Effectue une mesure sur tous les capteurs.
+
+        :return: (dict) Dictionnaire des mesures
+        """
+        self._consommer('mesure', 50)  # 50ms pour une mesure
+
+        mesures = {}
+        for nom, capteur in self.capteurs.items():
+            valeur = capteur.lire()
+            mesures[nom] = valeur
+            self.buffers[nom].ajouter(valeur)
+
+        self.nb_mesures += 1
+        return mesures
+
+    def statistiques(self):
+        """
+        Calcule les statistiques sur les données collectées.
+
+        :return: (dict) Statistiques par capteur
+        """
+        self._consommer('calcul', 20)  # 20ms pour les calculs
+
+        stats = {}
+        for nom, buffer in self.buffers.items():
+            unite = self.capteurs[nom].unite
+            moy = buffer.moyenne()
+            min_val, max_val = buffer.min_max()
+
+            stats[nom] = {
+                'moyenne': round(moy, 1) if moy else None,
+                'min': min_val,
+                'max': max_val,
+                'nb_mesures': len(buffer),
+                'unite': unite
+            }
+
+        return stats
+
+    def detecter_anomalies(self):
+        """
+        Détecte les valeurs anormales.
+        Une anomalie est une valeur qui s'écarte de plus de 2 écarts-types
+        de la moyenne.
+
+        :return: (list) Liste des anomalies détectées
+        """
+        self._consommer('calcul', 30)
+
+        anomalies = []
+        for nom, buffer in self.buffers.items():
+            if buffer.compte < 3:
+                continue
+
+            moy = buffer.moyenne()
+            ecart = buffer.ecart_type()
+
+            if ecart is None or ecart == 0:
+                continue
+
+            for valeur in buffer.valeurs():
+                if abs(valeur - moy) > 2 * ecart:
+                    anomalies.append({
+                        'capteur': nom,
+                        'valeur': valeur,
+                        'moyenne': round(moy, 2),
+                        'ecart_type': round(ecart, 2)
+                    })
+
+        return anomalies
+
+    def envoyer_cloud(self, donnees):
+        """
+        Simule l'envoi de données vers le cloud.
+
+        :param donnees: (dict) Données à envoyer
+        :return: (bool) Succès de l'envoi
+        """
+        self._consommer('envoi', 200)  # 200ms pour un envoi
+
+        # Simuler une latence réseau
+        time.sleep(0.1)
+
+        # Simuler un échec occasionnel (5% de chance)
+        if random.random() < 0.05:
+            print(f"[{self.nom}] Échec d'envoi - Données mises en cache")
+            self.buffer_envoi.append(donnees)
+            return False
+
+        # Afficher les données "envoyées"
+        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+        print(f"\n[{self.nom}] Envoi cloud @ {timestamp}")
+        for cle, valeur in donnees.items():
+            if isinstance(valeur, dict):
+                print(f"  {cle}: moy={valeur['moyenne']}{valeur['unite']}, "
+                      f"min={valeur['min']}, max={valeur['max']}")
+            else:
+                print(f"  {cle}: {valeur}")
+
+        return True
+
+    def activer_mode_eco(self):
+        """Active le mode économie d'énergie."""
+        self.mode_eco = True
+        print(f"[{self.nom}] Mode économie activé")
+
+    def desactiver_mode_eco(self):
+        """Désactive le mode économie d'énergie."""
+        self.mode_eco = False
+        print(f"[{self.nom}] Mode économie désactivé")
+
+    def rapport(self):
+        """
+        Génère un rapport formaté.
+
+        :return: (str) Rapport textuel
+        """
+        self._consommer('calcul', 10)
+
+        lignes = [
+            f"Station : {self.nom}",
+            f"Nombre total de mesures : {self.nb_mesures}",
+            f"Mode économie : {'Oui' if self.mode_eco else 'Non'}",
+            "",
+            "Statistiques par capteur :"
+        ]
+
+        stats = self.statistiques()
+        for nom, data in stats.items():
+            lignes.append(f"  {nom.capitalize()} :")
+            lignes.append(f"    Moyenne : {data['moyenne']} {data['unite']}")
+            lignes.append(f"    Min/Max : {data['min']} / {data['max']} {data['unite']}")
+            lignes.append(f"    Échantillons : {data['nb_mesures']}")
+
+        anomalies = self.detecter_anomalies()
+        if anomalies:
+            lignes.append("")
+            lignes.append(f"Anomalies détectées : {len(anomalies)}")
+            for a in anomalies[:5]:  # Limiter à 5
+                lignes.append(f"  - {a['capteur']}: {a['valeur']} "
+                              f"(moy={a['moyenne']}, σ={a['ecart_type']})")
+
+        return "\n".join(lignes)
+
+    # =========================================================================
+    # BONUS : Persistance locale
+    # =========================================================================
+
+    def sauvegarder_local(self, fichier="backup.json"):
+        """Sauvegarde les données en local (simulation de mémoire flash)."""
+        donnees = {
+            'station': self.nom,
+            'timestamp': time.strftime("%Y-%m-%d %H:%M:%S"),
+            'nb_mesures': self.nb_mesures,
+            'energie': self.energie_totale,
+            'buffers': {}
+        }
+
+        for nom, buffer in self.buffers.items():
+            donnees['buffers'][nom] = buffer.valeurs()
+
+        with open(fichier, 'w') as f:
+            json.dump(donnees, f, indent=2)
+
+        print(f"[{self.nom}] Données sauvegardées dans {fichier}")
+
+    def charger_local(self, fichier="backup.json"):
+        """Charge les données depuis la sauvegarde locale."""
+        try:
+            with open(fichier, 'r') as f:
+                donnees = json.load(f)
+
+            for nom, valeurs in donnees.get('buffers', {}).items():
+                if nom in self.buffers:
+                    for v in valeurs:
+                        self.buffers[nom].ajouter(v)
+
+            self.nb_mesures = donnees.get('nb_mesures', 0)
+            print(f"[{self.nom}] Données chargées depuis {fichier}")
+            return True
+
+        except FileNotFoundError:
+            print(f"[{self.nom}] Aucune sauvegarde trouvée")
+            return False
+
+    # =========================================================================
+    # BONUS : Protocole MQTT simulé
+    # =========================================================================
+
+    def publier(self, topic, message):
+        """Publie un message sur un topic (simulation MQTT)."""
+        timestamp = time.strftime("%H:%M:%S")
+        print(f"[MQTT {timestamp}] {self.nom}/{topic} -> {message}")
+
+
+# =============================================================================
+# PARTIE 5 : Programme principal
+# =============================================================================
+
+def main():
+    """Programme principal de la station météo."""
+
+    # Créer la station
+    station = StationMeteo("STATION_01", taille_buffer=20)
+
+    print("=" * 60)
+    print("   STATION MÉTÉO IoT - Simulation SoC")
+    print("=" * 60)
+
+    # Tenter de charger une sauvegarde précédente
+    station.charger_local()
+
+    # Simuler 30 mesures (accéléré pour le test)
+    nb_mesures = 30
+    intervalle = 0.5  # Secondes entre les mesures
+
+    try:
+        for i in range(nb_mesures):
+            # Effectuer une mesure
+            mesure = station.mesurer()
+            print(f"\rMesure {i+1:3d}/{nb_mesures}: "
+                  f"T={mesure['temperature']:5.1f}°C, "
+                  f"H={mesure['humidite']:3.0f}%, "
+                  f"P={mesure['pression']:6.1f}hPa", end="")
+
+            # Publier sur MQTT (simulation)
+            if (i + 1) % 5 == 0:
+                station.publier("temperature", mesure['temperature'])
+
+            # Envoyer au cloud toutes les 10 mesures
+            if (i + 1) % 10 == 0:
+                stats = station.statistiques()
+                station.envoyer_cloud(stats)
+
+            # Sauvegarder localement toutes les 15 mesures
+            if (i + 1) % 15 == 0:
+                station.sauvegarder_local()
+
+            # Simuler le mode éco après 20 mesures
+            if i == 19:
+                station.activer_mode_eco()
+
+            # Attendre avant la prochaine mesure
+            time.sleep(intervalle)
+
+    except KeyboardInterrupt:
+        print("\n\nArrêt demandé par l'utilisateur.")
+
+    # Rapport final
+    print("\n\n" + "=" * 60)
+    print("RAPPORT FINAL")
+    print("=" * 60)
+    print(station.rapport())
+    print(f"\nÉnergie totale consommée : {station.energie_totale:.6f} mWh")
+
+    # Sauvegarde finale
+    station.sauvegarder_local()
+
+
+# =============================================================================
+# TESTS
+# =============================================================================
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("TEST 1 : Capteur")
+    print("=" * 60)
+
+    capteur_temp = Capteur("Température", "°C", -20, 50, 1)
+    print(f"Capteur créé : {capteur_temp}")
+    print("Lectures :", [capteur_temp.lire() for _ in range(5)])
+
+    print("\n" + "=" * 60)
+    print("TEST 2 : Buffer circulaire")
+    print("=" * 60)
+
+    buffer = BufferCirculaire(5)
+    for i in range(1, 8):
+        buffer.ajouter(i)
+        print(f"Ajout {i}: données={buffer.donnees}, compte={buffer.compte}")
+
+    print(f"Moyenne : {buffer.moyenne()}")
+    print(f"Min/Max : {buffer.min_max()}")
+
+    print("\n" + "=" * 60)
+    print("TEST 3 : Station météo complète")
+    print("=" * 60)
+
+    main()
+
+
+# =============================================================================
+# RÉPONSES AUX QUESTIONS DE SYNTHÈSE
+# =============================================================================
+
+"""
+1. Pourquoi utiliser un buffer circulaire ?
+   - Allocation mémoire fixe et prévisible
+   - Pas de fragmentation mémoire
+   - Temps d'accès constant O(1)
+   - Adapté aux contraintes des microcontrôleurs (RAM limitée)
+
+2. Compromis fréquence/consommation :
+   - Plus de mesures = meilleure précision mais plus de consommation
+   - Mode éco : réduire la fréquence quand les données varient peu
+   - Adapter dynamiquement selon l'activité détectée
+
+3. Gestion de la perte de connexion :
+   - Stockage local temporaire (mémoire flash)
+   - File d'attente des messages
+   - Renvoi automatique à la reconnexion
+   - Compression des données pour économiser la bande passante
+
+4. Différences Python vs microcontrôleur :
+   - Python : haut niveau, garbage collector, pas de contraintes temps réel
+   - Microcontrôleur : C/C++/MicroPython, gestion manuelle mémoire,
+     interruptions matérielles, accès direct aux registres
+
+5. Optimisation SoC pour l'IoT :
+   - Composants faible consommation intégrés
+   - Modes de veille profonde
+   - Réveil sur interruption (capteur ou timer)
+   - Accélérateurs matériels pour crypto et radio
+"""

Soc/Cours_circuits_integres.md

@@ -0,0 +1,252 @@
+# Circuits intégrés et Systèmes sur Puce (SoC)
+
+---
+
+## 1. Rappels de Première
+
+### 1.1. Composition d'un ordinateur
+
+Nous avons vu en Première que l'évolution de l'architecture des ordinateurs a abouti à l'architecture de Von Neumann.
+
+Cette architecture possède les composants suivants :
+
+- **Mémoire**
+  - Mémoire de masse (disque dur, SSD)
+  - Mémoire vive (RAM)
+- **Processeur (CPU)**
+- **Carte graphique (GPU)** (optionnel)
+- **Périphériques d'entrée**
+  - Souris, clavier, microphone
+- **Périphériques de sortie**
+  - Écran, haut-parleurs
+
+Tous ces composants sont reliés par des **bus** (dans le cas d'un ordinateur de bureau, il s'agit de pistes sur la carte mère et de câbles).
+
+### 1.2. Évolution de la taille des ordinateurs
+
+- **1945 - ENIAC** : Le premier ordinateur électronique programmable faisait 167 m² et pesait 30 tonnes.
+
+![ENIAC](assets/Eniac.jpg)
+*L'ENIAC en 1945 (Source : Wikipédia)*
+
+- **1981 - IBM PC 5150** : Le premier ordinateur personnel grand public, tenant sur un bureau.
+
+![IBM PC 5150](assets/IBMPC5150.jpg)
+*L'IBM PC 5150 (Source : Wikipédia)*
+
+- **Aujourd'hui** : Ordinateurs portables, tablettes, smartphones... La puissance de l'ENIAC tient désormais dans une puce de quelques millimètres carrés.
+
+### 1.3. Évolution de la puissance : la loi de Moore
+
+**Gordon E. Moore**, cofondateur d'Intel en 1968, a formulé en 1965 une observation empirique devenue célèbre :
+
+> **Loi de Moore** : À coût constant, le nombre de transistors dans un microprocesseur double environ tous les deux ans.
+
+Cette loi s'est vérifiée pendant plus de 50 ans, permettant une croissance exponentielle de la puissance de calcul.
+
+**Limites physiques :**
+
+La miniaturisation des transistors atteint ses limites physiques :
+- En 2024, les processeurs les plus avancés utilisent une gravure en **3 nm** (environ 15 atomes de silicium)
+- Les effets quantiques (effet tunnel) deviennent problématiques en dessous de 5 nm
+- La dissipation thermique devient un défi majeur
+
+**Évolution des stratégies :**
+
+Face à ces limites, les fabricants adoptent de nouvelles approches :
+- **Augmentation du nombre de cœurs** : Les processeurs modernes ont 8, 16, voire 24 cœurs
+- **Architectures hybrides** : Mélange de cœurs performants et de cœurs économes (big.LITTLE, Intel Hybrid)
+- **Accélérateurs spécialisés** : NPU pour l'IA, GPU pour le calcul parallèle
+
+| Processeur | Année | Transistors | Gravure | Cœurs |
+|------------|-------|-------------|---------|-------|
+| Intel 4004 | 1971 | 2 300 | 10 µm | 1 |
+| Intel Pentium | 1993 | 3,1 millions | 800 nm | 1 |
+| Intel Core 2 | 2006 | 291 millions | 65 nm | 2 |
+| Apple M1 | 2020 | 16 milliards | 5 nm | 8 |
+| Apple M3 Pro | 2023 | 37 milliards | 3 nm | 12 |
+
+---
+
+## 2. Systèmes sur Puce (SoC)
+
+### 2.1. Définition
+
+Un **SoC** (*System on Chip* ou *Système sur Puce*) est un circuit intégré qui regroupe sur une seule puce tous les composants essentiels d'un système informatique :
+
+- Processeur (CPU)
+- Processeur graphique (GPU)
+- Mémoire cache
+- Contrôleur mémoire
+- Contrôleurs d'entrées/sorties
+- Parfois : modem, NPU (Neural Processing Unit), DSP...
+
+### 2.2. Avantages des SoC
+
+| Avantage | Explication |
+|----------|-------------|
+| **Compacité** | Tous les composants sur une seule puce |
+| **Consommation réduite** | Moins de distance entre composants = moins d'énergie |
+| **Performance** | Communication ultra-rapide entre composants |
+| **Coût** | Production en masse moins chère |
+| **Fiabilité** | Moins de connexions = moins de points de défaillance |
+
+### 2.3. Inconvénients des SoC
+
+| Inconvénient | Explication |
+|--------------|-------------|
+| **Non évolutif** | Impossible de remplacer un composant individuellement |
+| **Obsolescence** | Le système entier devient obsolète si un composant est dépassé |
+| **Réparation** | En cas de panne, tout le SoC doit être remplacé |
+| **Recyclage** | Difficile de séparer les différents matériaux |
+
+### 2.4. Exemples de SoC
+
+- **Smartphones** : Apple A17 Pro (iPhone), Qualcomm Snapdragon 8 Gen 3 (Android)
+- **Ordinateurs** : Apple M3 (Mac), Qualcomm Snapdragon X Elite (PC Windows)
+- **Objets connectés** : ESP32, Raspberry Pi Pico
+- **Consoles** : AMD APU (PS5, Xbox Series X)
+
+![Raspberry Pi](assets/raspberryPI.png)
+*Raspberry Pi : un micro-ordinateur basé sur un SoC ARM (Source : Wikipédia)*
+
+---
+
+## 3. Architectures ARM vs x86
+
+### 3.1. Deux philosophies différentes
+
+| Caractéristique | x86/x64 (Intel, AMD) | ARM |
+|-----------------|----------------------|-----|
+| **Philosophie** | CISC (Complex Instruction Set) | RISC (Reduced Instruction Set) |
+| **Instructions** | Nombreuses et complexes | Peu nombreuses et simples |
+| **Consommation** | Élevée | Faible |
+| **Performance brute** | Très élevée | Élevée (en progression) |
+| **Utilisation** | PC, serveurs | Smartphones, tablettes, embarqué |
+
+### 3.2. Convergence récente
+
+Depuis 2020, la frontière s'estompe :
+- **Apple Silicon (M1, M2, M3)** : Architecture ARM rivalisant avec x86 sur ordinateurs
+- **Windows on ARM** : Support des applications x86 par émulation
+- **Serveurs ARM** : Amazon Graviton, Ampere Altra
+
+### 3.3. RISC-V : l'architecture libre
+
+**RISC-V** est une architecture de processeur **open source** :
+- Pas de royalties à payer
+- Personnalisable selon les besoins
+- Adoptée par de nombreux fabricants (SiFive, Alibaba, Google)
+- Présente dans certains objets connectés et microcontrôleurs
+
+---
+
+## 4. Systèmes embarqués et IoT
+
+### 4.1. Définition
+
+Un **système embarqué** est un système informatique dédié à une tâche spécifique, intégré dans un appareil plus large. Il se caractérise par :
+
+- Ressources limitées (mémoire, puissance)
+- Contraintes temps réel
+- Faible consommation énergétique
+- Fiabilité élevée
+
+### 4.2. Exemples de systèmes embarqués
+
+| Domaine | Exemples |
+|---------|----------|
+| **Transport** | ABS, ESP, GPS, pilote automatique |
+| **Médical** | Pacemaker, pompe à insuline, IRM |
+| **Domotique** | Thermostat connecté, serrure intelligente |
+| **Industrie** | Automates programmables, robots |
+
+### 4.3. Internet des Objets (IoT)
+
+L'**IoT** (*Internet of Things*) désigne l'interconnexion d'objets du quotidien via Internet :
+
+- **Capteurs** : température, humidité, mouvement, luminosité
+- **Actionneurs** : moteurs, LED, relais
+- **Communication** : Wi-Fi, Bluetooth, LoRa, Zigbee
+- **Cloud** : stockage et traitement des données
+
+**Enjeux de l'IoT :**
+- Sécurité (objets souvent vulnérables)
+- Vie privée (collecte massive de données)
+- Interopérabilité (standards multiples)
+- Consommation énergétique
+
+---
+
+## 5. Impact environnemental
+
+### 5.1. Fabrication
+
+La production des SoC a un impact environnemental significatif :
+- **Terres rares** : extraction polluante et énergivore
+- **Eau ultra-pure** : des millions de litres par jour pour une usine
+- **Énergie** : fabrication très consommatrice
+
+### 5.2. Obsolescence
+
+Les SoC contribuent à l'obsolescence programmée :
+- Impossibilité de mise à niveau
+- Arrêt des mises à jour logicielles
+- Incompatibilité avec les nouveaux standards
+
+### 5.3. Recyclage
+
+Le recyclage des composants électroniques reste un défi :
+- Mélange de matériaux difficile à séparer
+- Présence de substances toxiques
+- Faible taux de recyclage effectif (< 20% mondial)
+
+**Initiatives positives :**
+- Indices de réparabilité obligatoires (France)
+- Droit à la réparation (Union Européenne)
+- Éco-conception des produits
+
+---
+
+## Synthèse
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    SYSTÈME SUR PUCE (SoC)                   │
+├─────────────────────────────────────────────────────────────┤
+│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────────────┐ │
+│  │   CPU   │  │   GPU   │  │   NPU   │  │  Contrôleurs    │ │
+│  │ (ARM/   │  │         │  │  (IA)   │  │  (USB, PCIe,    │ │
+│  │  x86)   │  │         │  │         │  │   Wi-Fi, etc.)  │ │
+│  └─────────┘  └─────────┘  └─────────┘  └─────────────────┘ │
+│  ┌─────────────────────────────────────────────────────────┐│
+│  │                    Mémoire Cache                        ││
+│  └─────────────────────────────────────────────────────────┘│
+│  ┌─────────────────────────────────────────────────────────┐│
+│  │              Bus interne haute vitesse                  ││
+│  └─────────────────────────────────────────────────────────┘│
+└─────────────────────────────────────────────────────────────┘
+              │                              │
+              ▼                              ▼
+        ┌──────────┐                  ┌──────────────┐
+        │   RAM    │                  │   Stockage   │
+        │(externe) │                  │   (SSD/eMMC) │
+        └──────────┘                  └──────────────┘
+```
+
+**Points clés à retenir :**
+
+1. Un **SoC** intègre tous les composants d'un ordinateur sur une seule puce
+2. Les architectures **ARM** dominent le mobile grâce à leur efficacité énergétique
+3. Les architectures **x86** restent dominantes sur PC et serveurs (mais ARM progresse)
+4. **RISC-V** est une alternative open source prometteuse
+5. Les **systèmes embarqués** et l'**IoT** utilisent massivement les SoC
+6. L'**impact environnemental** est un enjeu majeur de l'industrie des semi-conducteurs
+
+---
+
+Auteur : Florian Mathieu
+
+Licence CC BY NC
+
+<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.

Soc/EXERCICES.md

@@ -0,0 +1,169 @@
+# Exercices — Circuits intégrés et SoC
+
+---
+
+## Exercice 1 : Loi de Moore (QCM)
+
+1. La loi de Moore prédit que :
+   - [ ] a) La vitesse des processeurs double tous les ans
+   - [ ] b) Le nombre de transistors double environ tous les deux ans (à coût constant)
+   - [ ] c) La consommation électrique diminue de moitié tous les ans
+   - [ ] d) Le prix des processeurs double tous les deux ans
+
+2. Pourquoi la loi de Moore atteint-elle ses limites physiques ?
+   - [ ] a) Les transistors ne peuvent pas être plus petits qu'un atome
+   - [ ] b) Les effets quantiques perturbent le fonctionnement sous 5 nm
+   - [ ] c) La dissipation thermique devient ingérable
+   - [ ] d) Toutes les réponses ci-dessus
+
+3. Quelle stratégie les fabricants utilisent-ils pour contourner ces limites ?
+   - [ ] a) Augmenter la fréquence indéfiniment
+   - [ ] b) Multiplier le nombre de cœurs
+   - [ ] c) Utiliser des matériaux radioactifs
+   - [ ] d) Réduire la taille de la RAM
+
+---
+
+## Exercice 2 : Composants d'un SoC
+
+Un SoC moderne comme l'Apple M3 contient plusieurs composants.
+
+1. Parmi les éléments suivants, lesquels peuvent être intégrés dans un SoC ? (Plusieurs réponses possibles)
+   - [ ] CPU
+   - [ ] GPU
+   - [ ] Disque dur mécanique
+   - [ ] Contrôleur Wi-Fi
+   - [ ] Mémoire cache
+   - [ ] NPU (Neural Processing Unit)
+   - [ ] Écran
+   - [ ] Contrôleur USB
+
+2. Expliquer pourquoi un disque dur mécanique ne peut pas être intégré dans un SoC.
+
+3. Donner deux avantages et deux inconvénients de l'intégration de tous ces composants sur une seule puce.
+
+---
+
+## Exercice 3 : Calculs sur les transistors
+
+Le tableau suivant donne l'évolution du nombre de transistors dans les processeurs :
+
+| Processeur | Année | Transistors |
+|------------|-------|-------------|
+| Intel 4004 | 1971 | 2 300 |
+| Intel 8086 | 1978 | 29 000 |
+| Intel Pentium | 1993 | 3 100 000 |
+| Intel Core i7 (1ère gén.) | 2008 | 731 000 000 |
+| Apple M1 | 2020 | 16 000 000 000 |
+
+1. Calculer le facteur multiplicatif du nombre de transistors entre l'Intel 4004 et l'Apple M1.
+
+2. Si la loi de Moore était parfaitement respectée (doublement tous les 2 ans), combien de transistors devrait avoir un processeur en 2020, en partant de 2 300 transistors en 1971 ?
+
+3. Comparer avec le nombre réel de l'Apple M1. La loi de Moore a-t-elle été respectée ?
+
+---
+
+## Exercice 4 : ARM vs x86
+
+Compléter le tableau comparatif suivant :
+
+| Critère | Architecture x86 | Architecture ARM |
+|---------|------------------|------------------|
+| Type d'instructions | CISC | ... |
+| Consommation électrique | ... | Faible |
+| Utilisation principale | ... | Smartphones, tablettes |
+| Exemples de fabricants | Intel, AMD | ... |
+| Complexité des instructions | Élevée | ... |
+
+---
+
+## Exercice 5 : Systèmes embarqués
+
+Pour chaque système embarqué ci-dessous, identifier :
+- Le type de capteurs utilisés
+- Les contraintes principales (temps réel, consommation, fiabilité)
+- Un exemple de SoC qui pourrait être utilisé
+
+1. **Thermostat connecté**
+2. **Système ABS d'une voiture**
+3. **Montre connectée (smartwatch)**
+
+---
+
+## Exercice 6 : Impact environnemental
+
+Un smartphone contient environ 50 matériaux différents, dont des terres rares.
+
+1. Citer trois problèmes environnementaux liés à la fabrication des SoC.
+
+2. Pourquoi les SoC contribuent-ils à l'obsolescence programmée ?
+
+3. Proposer trois actions concrètes qu'un consommateur peut entreprendre pour réduire l'impact environnemental de ses appareils électroniques.
+
+---
+
+## Exercice 7 : Analyse d'un SoC réel
+
+Voici les spécifications du SoC **Qualcomm Snapdragon 8 Gen 3** (2023) :
+
+- CPU : 8 cœurs (1 × 3.3 GHz + 3 × 3.2 GHz + 2 × 3.0 GHz + 2 × 2.3 GHz)
+- GPU : Adreno 750
+- NPU : Hexagon
+- Gravure : 4 nm
+- Modem 5G intégré
+- Wi-Fi 7, Bluetooth 5.4
+
+1. Expliquer pourquoi le CPU possède des cœurs à différentes fréquences.
+
+2. À quoi sert le NPU (Neural Processing Unit) dans un smartphone moderne ?
+
+3. Quel est l'avantage d'avoir le modem 5G intégré au SoC plutôt que sur une puce séparée ?
+
+4. Calculer le rapport de fréquence entre le cœur le plus rapide et le cœur le plus lent.
+
+---
+
+## Exercice 8 : RISC-V et open source
+
+RISC-V est une architecture de processeur open source.
+
+1. Expliquer ce que signifie "open source" dans le contexte d'une architecture de processeur.
+
+2. Citer deux avantages de RISC-V par rapport à ARM ou x86.
+
+3. Donner un exemple de domaine où RISC-V est particulièrement adapté.
+
+4. Pourquoi les grandes entreprises (Google, Alibaba) s'intéressent-elles à RISC-V ?
+
+---
+
+## Exercice 9 : Conversion et calculs
+
+1. Un processeur utilise une gravure de 3 nm. Convertir cette valeur en :
+   - Micromètres (µm)
+   - Mètres
+
+2. Sachant qu'un atome de silicium mesure environ 0,2 nm de diamètre, combien d'atomes de silicium peuvent théoriquement tenir sur une largeur de 3 nm ?
+
+3. Pourquoi ce calcul montre-t-il les limites de la miniaturisation ?
+
+---
+
+## Exercice 10 : Synthèse
+
+Rédiger un paragraphe de 10 à 15 lignes expliquant pourquoi les SoC ont révolutionné l'informatique mobile et quels sont les défis pour l'avenir.
+
+Votre réponse doit aborder :
+- L'intégration des composants
+- L'efficacité énergétique
+- Les limites physiques de la miniaturisation
+- Les enjeux environnementaux
+
+---
+
+Auteur : Florian Mathieu
+
+Licence CC BY NC
+
+<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.

Soc/TP_Station_Meteo_IoT.md

@@ -0,0 +1,473 @@
+# TP : Station Météo IoT — Simulation d'un système embarqué
+
+## Contexte
+
+Vous travaillez pour une startup spécialisée dans les objets connectés. Votre mission est de développer le logiciel embarqué d'une **station météo connectée** basée sur un SoC (System on Chip).
+
+Cette station doit :
+- Collecter des données de capteurs (température, humidité, pression)
+- Traiter ces données localement (calculs de moyennes, détection d'anomalies)
+- Simuler l'envoi vers le cloud
+- Optimiser la consommation énergétique
+
+L'objectif est de comprendre comment fonctionne un système embarqué sur SoC et les contraintes associées.
+
+---
+
+## Objectifs pédagogiques
+
+- Comprendre le fonctionnement d'un système embarqué
+- Manipuler des données de capteurs simulés
+- Implémenter des algorithmes de traitement de données
+- Appréhender les contraintes de ressources limitées
+- Découvrir les concepts de l'IoT
+
+---
+
+## Partie 1 : Simulation des capteurs
+
+### 1.1. Classe Capteur
+
+Un capteur embarqué a des caractéristiques spécifiques :
+- Un nom (température, humidité, etc.)
+- Une unité de mesure
+- Une plage de valeurs valides
+- Une précision (nombre de décimales)
+
+Créer la classe `Capteur` :
+
+```python
+import random
+import time
+
+class Capteur:
+    """Simule un capteur embarqué sur SoC."""
+
+    def __init__(self, nom, unite, val_min, val_max, precision=1):
+        """
+        Initialise un capteur.
+
+        :param nom: (str) Nom du capteur
+        :param unite: (str) Unité de mesure
+        :param val_min: (float) Valeur minimale possible
+        :param val_max: (float) Valeur maximale possible
+        :param precision: (int) Nombre de décimales
+        """
+        self.nom = nom
+        self.unite = unite
+        self.val_min = val_min
+        self.val_max = val_max
+        self.precision = precision
+        self._derniere_valeur = None
+
+    def lire(self):
+        """
+        Simule une lecture du capteur.
+        Retourne une valeur réaliste (proche de la précédente).
+
+        :return: (float) Valeur mesurée
+        """
+        # À compléter
+        pass
+
+    def __repr__(self):
+        return f"Capteur({self.nom}, {self.unite})"
+```
+
+**Consignes pour la méthode `lire()` :**
+- Si c'est la première lecture, générer une valeur aléatoire dans la plage
+- Sinon, générer une valeur proche de la précédente (±10% de la plage)
+- Arrondir selon la précision
+- S'assurer que la valeur reste dans les limites
+
+### 1.2. Création des capteurs de la station
+
+Créer trois capteurs pour notre station :
+
+```python
+# Capteur de température : -20°C à 50°C, précision 0.1°C
+capteur_temp = Capteur("Température", "°C", -20, 50, precision=1)
+
+# Capteur d'humidité : 0% à 100%, précision 1%
+capteur_hum = Capteur("Humidité", "%", 0, 100, precision=0)
+
+# Capteur de pression : 950 hPa à 1050 hPa, précision 0.1 hPa
+capteur_pres = Capteur("Pression", "hPa", 950, 1050, precision=1)
+```
+
+**Test :**
+```python
+>>> for _ in range(5):
+...     print(f"T={capteur_temp.lire()}°C, H={capteur_hum.lire()}%, P={capteur_pres.lire()}hPa")
+T=22.3°C, H=65%, P=1013.2hPa
+T=23.1°C, H=67%, P=1012.8hPa
+T=22.8°C, H=66%, P=1013.5hPa
+...
+```
+
+---
+
+## Partie 2 : Gestionnaire de données
+
+### 2.1. Buffer circulaire
+
+Les systèmes embarqués ont une mémoire limitée. On utilise un **buffer circulaire** pour stocker les N dernières mesures sans allouer de mémoire dynamiquement.
+
+```python
+class BufferCirculaire:
+    """
+    Buffer circulaire pour stocker les dernières mesures.
+    Mémoire fixe, adapté aux systèmes embarqués.
+    """
+
+    def __init__(self, taille):
+        """
+        Initialise le buffer.
+
+        :param taille: (int) Nombre maximum d'éléments
+        """
+        self.taille = taille
+        self.donnees = [None] * taille  # Pré-allocation
+        self.index = 0
+        self.compte = 0
+
+    def ajouter(self, valeur):
+        """
+        Ajoute une valeur au buffer.
+        Écrase la plus ancienne si plein.
+
+        :param valeur: La valeur à ajouter
+        """
+        # À compléter
+        pass
+
+    def moyenne(self):
+        """
+        Calcule la moyenne des valeurs stockées.
+
+        :return: (float) Moyenne ou None si vide
+        """
+        # À compléter
+        pass
+
+    def min_max(self):
+        """
+        Retourne le minimum et le maximum.
+
+        :return: (tuple) (min, max) ou (None, None) si vide
+        """
+        # À compléter
+        pass
+
+    def est_plein(self):
+        """Vérifie si le buffer est plein."""
+        return self.compte >= self.taille
+
+    def __len__(self):
+        return self.compte
+```
+
+**Principe du buffer circulaire :**
+```
+Taille = 5, après ajout de 1, 2, 3, 4, 5, 6, 7 :
+
+Étape 1-5 : [1, 2, 3, 4, 5]  (remplissage normal)
+Étape 6   : [6, 2, 3, 4, 5]  (6 écrase 1)
+Étape 7   : [6, 7, 3, 4, 5]  (7 écrase 2)
+
+L'index "tourne" : index = (index + 1) % taille
+```
+
+---
+
+## Partie 3 : Station météo complète
+
+### 3.1. Classe StationMeteo
+
+Assembler les composants pour créer la station :
+
+```python
+class StationMeteo:
+    """
+    Station météo IoT simulant un système sur SoC.
+    """
+
+    def __init__(self, nom, taille_buffer=10):
+        """
+        Initialise la station.
+
+        :param nom: (str) Identifiant de la station
+        :param taille_buffer: (int) Taille des buffers de données
+        """
+        self.nom = nom
+
+        # Capteurs
+        self.capteurs = {
+            'temperature': Capteur("Température", "°C", -20, 50, 1),
+            'humidite': Capteur("Humidité", "%", 0, 100, 0),
+            'pression': Capteur("Pression", "hPa", 950, 1050, 1)
+        }
+
+        # Buffers pour chaque capteur
+        self.buffers = {
+            nom: BufferCirculaire(taille_buffer)
+            for nom in self.capteurs
+        }
+
+        # Compteur de mesures
+        self.nb_mesures = 0
+
+        # Mode économie d'énergie
+        self.mode_eco = False
+
+    def mesurer(self):
+        """
+        Effectue une mesure sur tous les capteurs.
+
+        :return: (dict) Dictionnaire des mesures
+        """
+        # À compléter
+        pass
+
+    def statistiques(self):
+        """
+        Calcule les statistiques sur les données collectées.
+
+        :return: (dict) Statistiques par capteur
+        """
+        # À compléter
+        pass
+
+    def detecter_anomalies(self):
+        """
+        Détecte les valeurs anormales.
+        Une anomalie est une valeur qui s'écarte de plus de 2 écarts-types
+        de la moyenne.
+
+        :return: (list) Liste des anomalies détectées
+        """
+        # À compléter (bonus)
+        pass
+
+    def rapport(self):
+        """
+        Génère un rapport formaté.
+
+        :return: (str) Rapport textuel
+        """
+        # À compléter
+        pass
+```
+
+### 3.2. Simulation d'envoi cloud
+
+Dans un vrai système IoT, les données sont envoyées vers le cloud. Simuler cette fonctionnalité :
+
+```python
+def envoyer_cloud(self, donnees):
+    """
+    Simule l'envoi de données vers le cloud.
+    En mode éco, regroupe les envois.
+
+    :param donnees: (dict) Données à envoyer
+    :return: (bool) Succès de l'envoi
+    """
+    # Simuler une latence réseau
+    import time
+    time.sleep(0.1)  # 100ms de latence simulée
+
+    # Simuler un échec occasionnel (5% de chance)
+    if random.random() < 0.05:
+        print(f"[{self.nom}] Échec d'envoi - Nouvelle tentative...")
+        return False
+
+    # Afficher les données "envoyées"
+    timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+    print(f"[{self.nom}] Envoi cloud @ {timestamp}")
+    for cle, valeur in donnees.items():
+        print(f"  {cle}: {valeur}")
+
+    return True
+```
+
+---
+
+## Partie 4 : Gestion de l'énergie
+
+### 4.1. Mode économie d'énergie
+
+Les systèmes embarqués doivent économiser l'énergie. Implémenter un mode économie :
+
+```python
+def activer_mode_eco(self):
+    """
+    Active le mode économie d'énergie.
+    - Réduit la fréquence des mesures
+    - Regroupe les envois cloud
+    """
+    self.mode_eco = True
+    print(f"[{self.nom}] Mode économie activé")
+
+def desactiver_mode_eco(self):
+    """Désactive le mode économie d'énergie."""
+    self.mode_eco = False
+    print(f"[{self.nom}] Mode économie désactivé")
+```
+
+### 4.2. Simulation de consommation
+
+Ajouter un suivi de la consommation énergétique simulée :
+
+```python
+class StationMeteo:
+    # Constantes de consommation (en mW)
+    CONSO_VEILLE = 0.5
+    CONSO_MESURE = 10
+    CONSO_ENVOI = 50
+    CONSO_CALCUL = 5
+
+    def __init__(self, ...):
+        ...
+        self.energie_totale = 0  # mWh consommés
+
+    def _consommer(self, activite, duree_ms):
+        """
+        Enregistre la consommation d'énergie.
+
+        :param activite: (str) Type d'activité
+        :param duree_ms: (int) Durée en millisecondes
+        """
+        conso = {
+            'veille': self.CONSO_VEILLE,
+            'mesure': self.CONSO_MESURE,
+            'envoi': self.CONSO_ENVOI,
+            'calcul': self.CONSO_CALCUL
+        }
+        # Convertir en mWh : mW * (ms / 3600000)
+        self.energie_totale += conso[activite] * (duree_ms / 3600000)
+```
+
+---
+
+## Partie 5 : Programme principal
+
+### 5.1. Boucle de fonctionnement
+
+Créer le programme principal qui simule le fonctionnement de la station :
+
+```python
+def main():
+    """Programme principal de la station météo."""
+
+    # Créer la station
+    station = StationMeteo("STATION_01", taille_buffer=20)
+
+    print("=" * 50)
+    print("   STATION MÉTÉO IoT - Simulation SoC")
+    print("=" * 50)
+
+    # Simuler 1 heure de fonctionnement (1 mesure par minute = 60 mesures)
+    nb_mesures = 60
+    intervalle = 1  # Secondes entre les mesures (accéléré pour la simulation)
+
+    try:
+        for i in range(nb_mesures):
+            # Effectuer une mesure
+            mesure = station.mesurer()
+            print(f"\nMesure {i+1}/{nb_mesures}: T={mesure['temperature']}°C, "
+                  f"H={mesure['humidite']}%, P={mesure['pression']}hPa")
+
+            # Envoyer au cloud toutes les 10 mesures
+            if (i + 1) % 10 == 0:
+                stats = station.statistiques()
+                station.envoyer_cloud(stats)
+
+            # Attendre avant la prochaine mesure
+            time.sleep(intervalle)
+
+    except KeyboardInterrupt:
+        print("\n\nArrêt demandé par l'utilisateur.")
+
+    # Rapport final
+    print("\n" + "=" * 50)
+    print("RAPPORT FINAL")
+    print("=" * 50)
+    print(station.rapport())
+    print(f"Énergie consommée : {station.energie_totale:.4f} mWh")
+
+
+if __name__ == "__main__":
+    main()
+```
+
+---
+
+## Partie 6 : Extensions (Bonus)
+
+### 6.1. Détection d'anomalies
+
+Implémenter la méthode `detecter_anomalies()` qui identifie les valeurs aberrantes.
+
+### 6.2. Persistance locale
+
+Ajouter une fonctionnalité de sauvegarde locale (fichier JSON) pour conserver les données en cas de perte de connexion :
+
+```python
+def sauvegarder_local(self, fichier="backup.json"):
+    """Sauvegarde les données en local (simulation de mémoire flash)."""
+    pass
+
+def charger_local(self, fichier="backup.json"):
+    """Charge les données depuis la sauvegarde locale."""
+    pass
+```
+
+### 6.3. Protocole de communication
+
+Simuler un protocole de communication simple (type MQTT) :
+
+```python
+def publier(self, topic, message):
+    """Publie un message sur un topic (simulation MQTT)."""
+    print(f"[MQTT] {topic} -> {message}")
+```
+
+### 6.4. Multi-stations
+
+Créer un réseau de plusieurs stations qui communiquent entre elles et agrègent leurs données.
+
+---
+
+## Questions de synthèse
+
+1. Pourquoi utilise-t-on un buffer circulaire plutôt qu'une liste dynamique sur un système embarqué ?
+
+2. Quels sont les compromis à faire entre fréquence de mesure et consommation énergétique ?
+
+3. Comment un vrai système IoT gère-t-il la perte de connexion réseau ?
+
+4. Quelles sont les différences entre le code Python de simulation et le code réel sur un microcontrôleur ?
+
+5. Comment l'architecture SoC permet-elle d'optimiser la consommation dans ce type d'application ?
+
+---
+
+## Barème indicatif
+
+| Partie | Points |
+|--------|--------|
+| Partie 1 : Capteurs | 3 |
+| Partie 2 : Buffer circulaire | 4 |
+| Partie 3 : Station complète | 5 |
+| Partie 4 : Gestion énergie | 3 |
+| Partie 5 : Programme principal | 3 |
+| Partie 6 : Bonus | 2 |
+| **Total** | **20** |
+
+---
+
+Auteur : Florian Mathieu
+
+Licence CC BY NC
+
+<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.