Introduction à MicroPython

Qu’est-ce que MicroPython ?

MicroPython est une implémentation légère et efficace de Python 3, conçue spécifiquement pour tourner sur des microcontrôleurs et dans des environnements contraints. C’est du vrai Python — pas un sous-ensemble simplifié ou un langage “inspiré de” — mais une version taillée pour tenir dans quelques centaines de kilooctets de mémoire.

Naissance du projet — Damien George, 2013

Tout commence avec Damien George, un physicien australien passionné de robotique. En 2013, il s’attaque à un défi apparemment impossible : faire tourner Python sur un microcontrôleur. Python est réputé pour être gourmand en mémoire — les implémentations classiques nécessitent des mégaoctets de RAM. Les microcontrôleurs en ont des centaines de kilooctets, parfois moins.

Il lance en 2013 une campagne Kickstarter pour financer le développement et la fabrication d’une première carte dédiée, la pyboard. La campagne est un succès. MicroPython est rendu open source sous licence MIT.

Aujourd’hui, le projet est maintenu par George Robotics Limited et une communauté mondiale de contributeurs. Il fonctionne sur des dizaines de cartes différentes : ESP32, ESP8266, Raspberry Pi Pico, STM32, et bien d’autres.

Ce que MicroPython embarque

MicroPython n’est pas un simple interpréteur. Il intègre :

• Un compilateur Python complet — ton code est compilé en bytecode avant d’être exécuté
• Un REPL (Read-Eval-Print Loop) avec historique, complétion par tabulation et auto-indentation
• La gestion des entiers de précision arbitraire, des closures, des list comprehensions, des générateurs et des exceptions — les mêmes qu’en Python desktop
• Un ramasse-miettes (garbage collector) pour la gestion automatique de la mémoire
• Le multithreading via le module _thread
• La compatibilité avec Python 3.4 pour la syntaxe, avec des fonctionnalités sélectionnées des versions suivantes

Python vs MicroPython

MicroPython vs Arduino (C++)

En pratique : pour l’immense majorité des projets fablab — lire des capteurs, piloter des LEDs, se connecter en WiFi, afficher sur un écran — MicroPython est largement suffisant et beaucoup plus accessible. On perd peut-être un facteur 10 en vitesse d’exécution par rapport au C++, mais l’ESP32 à 240 MHz a largement de la marge.

Les cartes compatibles

MicroPython tourne sur une grande variété de microcontrôleurs. Les principales familles :

Les modules MicroPython sur l’ESP32

machine — accès direct au matériel

C’est le module central. Il donne accès à tout le matériel de la carte :

from machine import Pin, PWM, ADC, I2C, SPI, UART

# Sortie numérique (LED)
led = Pin(2, Pin.OUT)
led.on()
led.off()
led.value(not led.value())   # bascule

# Entrée numérique (bouton)
btn = Pin(25, Pin.IN)
print(btn.value())           # 0 ou 1

# PWM — signal à fréquence et rapport cyclique variables
pwm = PWM(Pin(2), freq=500)
pwm.duty(512)                # 50% de 0 à 1023

# ADC — mesure de tension analogique
adc = ADC(Pin(35))
adc.atten(ADC.ATTN_11DB)     # plage 0–3.6 V
raw = adc.read()             # 0 à 4095 (12 bits)

# Fréquence CPU
import machine
machine.freq(240_000_000)    # 240 MHz (maximum de l'ESP32)
print(machine.freq())        # affiche la fréquence actuelle

network — WiFi et connexion

import network

# Mode Station — se connecter à un routeur WiFi
sta = network.WLAN(network.STA_IF)
sta.active(True)
sta.connect('NomDuReseau', 'motdepasse')
while not sta.isconnected():
    pass
print('Connecté — IP :', sta.ifconfig()[0])

# Mode Access Point — l'ESP32 crée son propre réseau
ap = network.WLAN(network.AP_IF)
ap.active(True)
ap.config(essid='MonESP32', password='12345678')
print('AP actif — IP :', ap.ifconfig()[0])

time — temporisation et mesure du temps

from time import sleep, sleep_ms, sleep_us, ticks_ms, ticks_us

sleep(1)           # attendre 1 seconde
sleep_ms(500)      # attendre 500 millisecondes
sleep_us(100)      # attendre 100 microsecondes

# Mesure du temps écoulé
t0 = ticks_ms()
# ... code à mesurer ...
delta = ticks_ms() - t0
print("Durée :", delta, "ms")

esp32 — fonctions spécifiques à l’ESP32

from esp32 import hall_sensor, raw_temperature

print("Température interne du chip :", raw_temperature(), "°F")
print("Capteur Hall (champ magnétique) :", hall_sensor())

neopixel — LED WS2812 adressables

from neopixel import NeoPixel
from machine import Pin

np = NeoPixel(Pin(26), 8)    # 8 LEDs sur la broche 26
np[0] = (255, 0, 0)          # LED 0 en rouge
np[3] = (0, 255, 100)        # LED 3 en vert-cyan
np.write()                   # envoyer le tout d'un coup

Autres modules utiles

Le REPL — ton meilleur outil pour apprendre

Le REPL (Read-Eval-Print Loop) est une console interactive directe sur l’ESP32. Tu tapes une instruction, elle s’exécute immédiatement sur la carte, et tu vois le résultat — sans compiler, sans transférer de fichier.

>>> from machine import Pin
>>> led = Pin(2, Pin.OUT)
>>> led.on()        # La LED s'allume instantanément !
>>> led.off()
>>> 2 + 2
4
>>> [x**2 for x in range(5)]
[0, 1, 4, 9, 16]

Le REPL de MicroPython inclut :

• Historique : flèche ↑ pour rappeler les commandes précédentes
• Complétion : Tab pour compléter les noms de fonctions et d’attributs
• Auto-indentation : les blocs if, for, while s’indentent automatiquement
• Ctrl+C : interrompre le programme en cours
• Ctrl+D : soft reset (relance boot.py puis main.py)

Thonny — l’IDE recommandé

Thonny est l’environnement de développement (IDE) recommandé pour débuter avec MicroPython. Il est gratuit, multiplateforme, et a été conçu spécifiquement pour l’enseignement. Il intègre déjà Python 3 — pas besoin d’installation supplémentaire.

Les zones de l’interface

Connecter l’ESP32 à Thonny

Opérations courantes

Raccourcis clavier essentiels

Flasher MicroPython sur une nouvelle carte

Si ta carte est neuve ou si MicroPython n’y est pas installé :

1. Brancher l’ESP32 en USB
2. Outils → Configurer l’interpréteur → clic sur “Install or update MicroPython”
3. Sélectionner la variante : ESP32 / ESP32-S3 / Pico selon ta carte
4. Cliquer sur Install — Thonny télécharge et flash le firmware automatiquement
5. Une fois terminé, redémarrer Thonny et se connecter normalement

Le système de fichiers de l’ESP32

L’ESP32 possède une mémoire Flash de 4 Mo dont une partie est réservée à un système de fichiers accessible depuis MicroPython. Tu peux y stocker des scripts, des bibliothèques, des données de configuration, des fichiers texte…

Deux fichiers ont un rôle spécial et sont exécutés automatiquement à chaque démarrage :

Ordre de démarrage : reset → boot.py → main.py → REPL (si main.py absent ou terminé)

Organiser ses fichiers

La bonne pratique est de créer un dossier /lib pour les modules tiers — MicroPython l’ajoute automatiquement au chemin de recherche :

/                    ← racine de la Flash
├── boot.py          ← config WiFi, init
├── main.py          ← programme principal
├── lib/             ← bibliothèques tierces
│   ├── ssd1306.py   ← driver écran OLED
│   └── ds18x20.py   ← driver DS18B20
└── data/            ← données de ton projet
    └── config.txt   ← paramètres

Gérer les fichiers depuis le REPL

import os

# Lister les fichiers
os.listdir()               # ['boot.py', 'main.py', 'lib']
os.listdir('/lib')         # contenu du dossier lib

# Créer / supprimer / renommer
os.mkdir('data')           # créer un dossier
os.remove('old.py')        # supprimer un fichier
os.rename('a.py', 'b.py') # renommer ou déplacer

# Infos sur un fichier
stat = os.stat('main.py')
print("Taille :", stat[6], "octets")

# Dossier courant
os.getcwd()                # '/'
os.chdir('/lib')           # changer de dossier

Lire et écrire des fichiers

# Écrire un fichier de configuration
with open('config.txt', 'w') as f:
    f.write('ssid=MonWiFi\n')
    f.write('password=secret\n')

# Lire ce fichier
with open('config.txt', 'r') as f:
    contenu = f.read()
    print(contenu)

# Supprimer le fichier
os.remove('config.txt')

Mémoire disponible

import os, gc

# Mémoire RAM
gc.collect()                          # libérer ce qui peut l'être
print("RAM libre :", gc.mem_free(), "octets")
print("RAM utilisée :", gc.mem_alloc(), "octets")

# Espace Flash
fs = os.statvfs('/')
bloc = fs[0]
print("Flash libre :", fs[3] * bloc, "octets sur", fs[2] * bloc, "octets")

Prochaine étape