# Importer les classes Pin et Timer du module 'machine'
from machine import Pin, Timer

# Configurer la broche de la LED intégrée comme une sortie.
# Sur beaucoup de cartes ESP32, c'est la broche 2. Sur le Pico, c'est la 25.
# On utilise 'Pin.OUT' pour spécifier que c'est une sortie.
led = Pin(2, Pin.OUT)

# Créer une fonction pour inverser l'état de la LED
def toggle_led(timer):
 led.toggle()

# Créer un objet Timer
tim = Timer()

# Initialiser le timer pour qu'il appelle la fonction 'toggle_led'
# toutes les 500 millisecondes (soit une fréquence de 2 Hz).
# Cela fera clignoter la LED une fois par seconde (500ms allumée, 500ms éteinte).
tim.init(freq=2, mode=Timer.PERIODIC, callback=toggle_led)

# À partir de maintenant, la LED clignote en arrière-plan !
# Vous pouvez continuer à utiliser le REPL pour d'autres tâches.

**Fichier `main.py`:** ```python
# main.py
# S'exécute après boot.py. Contient la logique principale.
import time
from machine import Pin, I2C
# Supposons une bibliothèque 'bme280' pour un capteur de température/pression
import bme280 

# Initialisation du bus I2C pour communiquer avec le capteur
i2c = I2C(0, scl=Pin(22), sda=Pin(21))
sensor = bme280.BME280(i2c=i2c)

while True:
 # Lecture des données du capteur
 temp, press, hum = sensor.read_compensated_data()

 # Affichage des données
 print(f"Température: {temp:.2f}°C, Pression: {press/100:.2f} hPa, Humidité: {hum:.2f}%")

 # Attendre 10 secondes avant la prochaine mesure
 time.sleep(10)

## Introduction : Le paradoxe de l'IoT Vous connaissez probablement Python comme le langage de prédilection pour le développement web (avec Django ou Flask), l'analyse de données ou l'intelligence artificielle. Ces domaines évoquent des serveurs puissants, des gigaoctets de RAM et des processeurs multi-cœurs. À l'opposé, l'Internet des Objets (IoT) nous plonge dans un monde de contraintes : des microcontrôleurs avec quelques kilo-octets de RAM, une puissance de calcul limitée et une consommation énergétique minimale. Le paradoxe est donc le suivant : comment un langage de haut niveau, connu pour sa flexibilité mais aussi pour être plus lent que les langages compilés, peut-il s'imposer dans un domaine historiquement dominé par le C, le C++ et l'Assembleur ? La réponse tient en un mot : **productivité**. Le temps de développement est une ressource aussi précieuse, sinon plus, que les cycles d'horloge d'un processeur. C'est ici que MicroPython entre en scène, en proposant un compromis quasi idéal entre performance et facilité d'utilisation. Imaginez que construire un objet connecté en C, c'est comme assembler une voiture de sport pièce par pièce dans votre garage. C'est extrêmement performant, vous contrôlez tout, mais cela demande une expertise immense et beaucoup de temps. Utiliser MicroPython, c'est un peu comme recevoir un kit de construction avancé : les pièces complexes (gestion de la mémoire, pilotes bas niveau) sont déjà pré-assemblées, vous permettant de vous concentrer sur la logique et la créativité de votre projet. ## Le monde de l'embarqué avant MicroPython Pour apprécier pleinement la révolution MicroPython, il faut comprendre les défis du développement embarqué traditionnel. Un développeur travaillant sur un microcontrôleur avec des outils classiques fait face à un cycle de développement souvent laborieux : 1. **Écriture du code** : En C ou C++, en gérant manuellement la mémoire (pointeurs, allocation, libération) et en interagissant directement avec les registres matériels. 2. **Compilation** : Le code source est transformé en un fichier binaire exécutable. Cette étape, appelée compilation croisée, se fait sur un ordinateur puissant (votre PC) pour une architecture cible différente (le microcontrôleur, par exemple ARM Cortex-M). 3. **Téléversement (Flashing)** : Le binaire compilé est transféré dans la mémoire flash du microcontrôleur via une liaison série ou un programmateur dédié (JTAG/SWD). 4. **Exécution & Débogage** : Le microcontrôleur redémarre et exécute le code. Si une erreur survient, le débogage est complexe. Il faut souvent recourir à des LED de statut, une sortie série (UART) ou un débogueur matériel pour inspecter l'état du système. Le moindre changement dans le code nécessite de reprendre le cycle depuis le début. Ce processus est robuste et produit un code extrêmement optimisé, mais il est lent et rigide. Il n'y a pas de place pour l'expérimentation rapide ou l'itération agile qui sont la norme dans le développement logiciel moderne. ## MicroPython : Le meilleur des deux mondes MicroPython, créé par Damien George en 2013, est une réimplémentation complète et efficace du langage Python 3. Il est conçu pour fonctionner directement sur des microcontrôleurs "nus" (bare-metal), sans nécessiter de système d'exploitation sous-jacent. Il change radicalement le paradigme de développement grâce à une fonctionnalité clé : le **REPL (Read-Eval-Print Loop)**. Le REPL est une console interactive qui tourne *directement sur le microcontrôleur*. Vous pouvez vous y connecter via USB et taper des commandes Python qui sont exécutées instantanément. Besoin de savoir si une broche (pin) est à l'état haut ? Tapez la commande et obtenez la réponse. Vous voulez allumer une LED ? Une seule ligne de code suffit. Cette interactivité transforme le débogage et le prototypage. Le cycle long et fastidieux de compilation-téléversement est remplacé par un dialogue en temps réel avec votre matériel. Les avantages principaux sont donc : * **Développement Rapide** : La syntaxe claire de Python et le REPL permettent de prototyper des idées en quelques minutes, et non en heures. * **Accessibilité** : Des millions de développeurs connaissent déjà Python. La barrière à l'entrée pour le monde de l'embarqué s'effondre. * **Bibliothèques de haut niveau** : MicroPython inclut des modules pour gérer facilement les périphériques standards (GPIO, I2C, SPI, ADC) et des fonctionnalités complexes comme le réseau (WiFi, Ethernet) ou le système de fichiers. * **Gestion automatique de la mémoire** : Fini les `malloc()` et `free()`. Le ramasse-miettes (garbage collector) de MicroPython s'occupe de la gestion de la mémoire, évitant ainsi une des sources d'erreurs les plus courantes en C/C++. ## MicroPython vs. Python Standard (CPython) Il est crucial de comprendre que MicroPython n'est pas simplement une copie de Python sur un microcontrôleur. C'est une implémentation optimisée pour les environnements contraints. Cela implique quelques différences importantes par rapport à CPython (l'implémentation standard que vous utilisez sur votre ordinateur). Le but n'est pas de remplacer CPython, mais d'offrir une expérience de développement Pythonique dans un contexte où CPython ne pourrait jamais fonctionner. Le tableau suivant résume les distinctions clés. ## L'Écosystème Matériel : Microcontrôleur ou Ordinateur Monocarte ? Une confusion fréquente pour les débutants est la différence entre un microcontrôleur (comme un ESP32 ou un Raspberry Pi Pico) et un ordinateur monocarte (SBC - Single-Board Computer) comme un Raspberry Pi 4. C'est une distinction fondamentale. * **Microcontrôleur (MCU)** : C'est un système sur une puce simple, sans système d'exploitation. Il exécute un seul programme en boucle (le firmware). C'est la cible de **MicroPython**. Exemples : ESP32, ESP8266, STM32, Raspberry Pi Pico. * **Ordinateur Monocarte (SBC)** : C'est un ordinateur complet sur une seule carte. Il exécute un système d'exploitation complet (généralement Linux). Il peut faire tourner plusieurs programmes en même temps. C'est la cible du **Python standard (CPython)**. Exemples : Raspberry Pi (modèles 1, 2, 3, 4, 5, Zero), BeagleBone Black. Un SBC est parfait pour des tâches complexes nécessitant de la puissance de calcul, comme le traitement d'image ou l'hébergement d'un serveur web. Un MCU est idéal pour des tâches de contrôle en temps réel, la lecture de capteurs et la gestion de l'énergie. Le diagramme ci-dessous illustre les deux approches. ## Premiers Pas Pratiques : Faire clignoter une LED Passons à la pratique. Le "Hello, World!" de l'embarqué est de faire clignoter une LED. Voici à quoi cela ressemble en MicroPython, par exemple sur une carte de type ESP32 ou Raspberry Pi Pico. Tout d'abord, vous vous connectez au REPL de la carte avec un outil comme Thonny IDE ou `rshell`. Une fois dans le REPL (indiqué par $>>>$), vous pouvez importer les bibliothèques nécessaires et interagir avec le matériel : ```python # Importer les classes Pin et Timer du module 'machine' from machine import Pin, Timer # Configurer la broche de la LED intégrée comme une sortie. # Sur beaucoup de cartes ESP32, c'est la broche 2. Sur le Pico, c'est la 25. # On utilise 'Pin.OUT' pour spécifier que c'est une sortie. led = Pin(2, Pin.OUT) # Créer une fonction pour inverser l'état de la LED def toggle_led(timer): led.toggle() # Créer un objet Timer tim = Timer() # Initialiser le timer pour qu'il appelle la fonction 'toggle_led' # toutes les 500 millisecondes (soit une fréquence de 2 Hz). # Cela fera clignoter la LED une fois par seconde (500ms allumée, 500ms éteinte). tim.init(freq=2, mode=Timer.PERIODIC, callback=toggle_led) # À partir de maintenant, la LED clignote en arrière-plan ! # Vous pouvez continuer à utiliser le REPL pour d'autres tâches. ``` Ce code est remarquable. En quelques lignes lisibles, nous avons configuré une broche, défini un comportement et utilisé une interruption matérielle (le Timer) pour exécuter notre code de manière périodique, sans bloquer le programme principal. Tenter de faire la même chose en C nécessiterait une configuration de registres et une gestion des interruptions bien plus complexes. ## Structure d'un projet MicroPython Pour un projet permanent, on ne tape pas le code dans le REPL à chaque démarrage. MicroPython recherche deux fichiers spéciaux dans le système de fichiers de la carte au démarrage : 1. **$boot.py$** : Ce script est exécuté en premier, au démarrage de la carte. Il est utilisé pour les configurations initiales qui ne devraient pas être modifiées, comme l'initialisation du WiFi ou la configuration de services essentiels. 2. **$main.py$** : Ce script est exécuté juste après $boot.py$. C'est là que réside la logique principale de votre application. Un projet simple de station météo pourrait donc ressembler à ceci : **Fichier `boot.py`:** ```python # boot.py # S'exécute au démarrage. Gère la connexion WiFi. import network SSID = 'MonReseauWiFi' PASSWORD = 'MonMotDePasseSecret' station = network.WLAN(network.STA_IF) station.active(True) station.connect(SSID, PASSWORD) while not station.isconnected(): pass print('Connexion réussie !') print('IP:', station.ifconfig()[0]) ``` **Fichier `main.py`:** ```python # main.py # S'exécute après boot.py. Contient la logique principale. import time from machine import Pin, I2C # Supposons une bibliothèque 'bme280' pour un capteur de température/pression import bme280 # Initialisation du bus I2C pour communiquer avec le capteur i2c = I2C(0, scl=Pin(22), sda=Pin(21)) sensor = bme280.BME280(i2c=i2c) while True: # Lecture des données du capteur temp, press, hum = sensor.read_compensated_data() # Affichage des données print(f"Température: {temp:.2f}°C, Pression: {press/100:.2f} hPa, Humidité: {hum:.2f}%") # Attendre 10 secondes avant la prochaine mesure time.sleep(10) ``` Cette structure claire sépare la configuration de l'application, une bonne pratique qui rend le code plus maintenable. ## Conclusion : Une nouvelle ère pour l'embarqué MicroPython ne remplace pas le C ou le C++ pour les applications nécessitant des performances extrêmes ou un contrôle matériel au cycle d'horloge près. Cependant, pour une très grande majorité de projets IoT, la vitesse de développement, la facilité de maintenance et l'écosystème riche de Python offrent un avantage considérable. Vous avez maintenant compris la philosophie derrière MicroPython, ses avantages par rapport à l'approche traditionnelle, et ses différences avec le Python que vous connaissez. Vous êtes prêt à explorer ce monde fascinant où le code rencontre le monde physique. La prochaine étape ? Choisir une carte de développement, installer un IDE comme Thonny, et commencer à faire clignoter votre première LED. Bienvenue dans le monde de l'IoT avec Python.