Qu'est-ce que MicroPython ? Bases, REPL et premiers programmes

MicroPython est une réimplémentation petite et rapide du langage Python 3 pour les microcontrôleurs. Une fois MicroPython installé sur une carte comme la Raspberry Pi Pico ou l'ESP32, la carte exécute elle-même le code Python : tu tapes une commande sans rien compiler et tu vois la LED s'allumer aussitôt. Si tu as appris Python en cours ou sur ton ordinateur, tu peux, avec la même syntaxe, lire des broches, piloter des moteurs, récupérer des mesures de capteurs et te connecter au Wi-Fi.

Dans ce guide, tu découvriras ce qui distingue MicroPython du Python classique, le REPL qui te permet de dialoguer instantanément avec la carte, et les modules que tu utiliseras le plus, à savoir machine.Pin, PWM, ADC et I2C, avec des exemples de code. Tu verras ensuite la différence entre time.sleep et ticks_ms, les fichiers main.py et boot.py qui s'exécutent au démarrage, l'envoi de fichiers avec Thonny et mpremote, l'ajout de bibliothèques avec mip et l'installation du firmware sur la Pico et l'ESP32. Dans la dernière partie, nous comparons MicroPython et Arduino C++ côte à côte.

Qu'est-ce que MicroPython et en quoi diffère-t-il de Python ?

MicroPython est un projet open source lancé en 2013 par Damien George pour une petite carte, et il prend aujourd'hui en charge des dizaines de microcontrôleurs. Le firmware que tu installes sur la carte contient l'interpréteur Python, les modules de base et un petit système de fichiers. Ton code est d'abord transformé en bytecode sur la carte, puis l'interpréteur exécute ce bytecode pas à pas. Comme il est impossible de faire tenir tout le Python de ton ordinateur dans quelques centaines de Ko de RAM, le langage reste le même, mais la plupart des bibliothèques sont soit allégées, soit absentes. En échange, on y trouve quelque chose que le Python de bureau n'a pas : le module machine, qui donne un accès direct au matériel.

Les cartes qui font tourner MicroPython

Installer le firmware MicroPython sur la Pico et l'ESP32

1. Pico : Maintiens le bouton BOOTSEL de la carte enfoncé en branchant le câble USB, puis relâche-le. Un lecteur nommé RPI-RP2 apparaît sur l'ordinateur (RP2350 sur la Pico 2).
2. Télécharge sur la page officielle de MicroPython le fichier .uf2 qui correspond à ta carte (RPI_PICO pour la Pico, RPI_PICO_W pour la Pico W) et fais-le glisser sur ce lecteur.
3. Une fois la copie terminée, la carte redémarre toute seule et le lecteur disparaît ; MicroPython est installé. Dans Thonny, choisis MicroPython (Raspberry Pi Pico) dans Outils > Options > Interpréteur.
4. ESP32 : Si Python est installé sur ton ordinateur, tape pip install esptool dans la ligne de commande. Branche la carte et repère son port (par exemple COM3 sous Windows, /dev/ttyUSB0 sous Linux).
5. Efface d'abord la flash : esptool.py --chip esp32 --port COM3 erase_flash. Si la carte ne se connecte pas, maintiens le bouton BOOT pendant l'exécution de la commande.
6. Écris le firmware : esptool.py --chip esp32 --port COM3 --baud 460800 write_flash -z 0x1000 ESP32_GENERIC-....bin. Sur l'ESP32-S3 et l'ESP32-C3, l'adresse est 0x0. L'option Install or update MicroPython (esptool) de Thonny fait la même chose depuis une fenêtre.

Le REPL : dialoguer instantanément avec la carte

Le REPL (Read-Eval-Print Loop) est la ligne de commande que la carte t'ouvre par le port série. L'invite >>> que tu vois dans la fenêtre Shell en bas de Thonny indique que le REPL t'attend. Tape 1 + 1 et la carte calcule puis renvoie 2 ; tape from machine import Pin puis Pin("LED", Pin.OUT).value(1) et la LED de la Pico s'allume à l'instant même. Il n'existe pas de moyen plus rapide que le REPL pour lire la valeur d'un capteur, vérifier qu'une broche est bien câblée ou découvrir le fonctionnement d'une bibliothèque, sans attendre une compilation ni un téléversement.

Premier programme et son équivalent en Arduino C++

1# İlk program: dahili LED'i yakıp söndür / First program: blink the onboard LED
2from machine import Pin
3import time
4
5led = Pin("LED", Pin.OUT)        # Pico ve Pico W; ESP32'de Pin(2, Pin.OUT) / Pico and Pico W; Pin(2, Pin.OUT) on ESP32
6
7while True:
8    led.value(1)                 # yak / on
9    time.sleep(0.5)              # saniye cinsinden / in seconds
10    led.value(0)                 # söndür / off
11    time.sleep(0.5)

1// Aynı program Arduino C++ ile / The same program in Arduino C++
2void setup() {
3  pinMode(LED_BUILTIN, OUTPUT);
4}
5
6void loop() {
7  digitalWrite(LED_BUILTIN, HIGH);
8  delay(500);                    // milisaniye cinsinden / in milliseconds
9  digitalWrite(LED_BUILTIN, LOW);
10  delay(500);
11}

Les deux programmes font la même chose, mais leur structure diffère. MicroPython n'a ni setup() ni loop() : le fichier s'exécute une fois de haut en bas et c'est toi qui construis la boucle infinie avec while True:. Au lieu des accolades et des points-virgules, on utilise l'indentation ; toutes les lignes à l'intérieur de la boucle doivent être indentées de la même façon (en général 4 espaces). L'attente utilise aussi une autre unité : time.sleep(0.5) prend des secondes, alors que le delay(500) d'Arduino prend des millisecondes. En MicroPython, on utilise time.sleep_ms() pour les millisecondes et time.sleep_us() pour les microsecondes. Les bases côté Arduino sont dans Les bases de la programmation Arduino.

machine.Pin : entrées et sorties numériques

time.sleep et ticks_ms : mesurer le temps sans bloquer

time.sleep() met la carte complètement en attente ; pendant ce temps, aucun bouton n'est lu et aucun capteur n'est consulté. Pour mener plusieurs tâches en parallèle, tu utilises l'équivalent MicroPython de la méthode millis() d'Arduino : time.ticks_ms() donne les millisecondes écoulées depuis le démarrage et time.ticks_diff(nouveau, ancien) calcule l'écart entre deux instants. Il est important de calculer cet écart avec ticks_diff et non par une simple soustraction ; le compteur repart de zéro après une certaine valeur et, à ce moment-là, la soustraction donne un résultat faux. Le code ci-dessous fait clignoter la LED sans bloquer tout en surveillant un bouton par interruption (IRQ) ; chaque appui change la vitesse de clignotement.

1# delay kullanmadan iki iş: LED yanıp söner, buton kesmeyle modu değiştirir
2# Two jobs without blocking: the LED blinks, a button interrupt switches the mode
3from machine import Pin
4import time
5
6led = Pin(15, Pin.OUT)                       # LED + 220 Ω, GP15
7buton = Pin(14, Pin.IN, Pin.PULL_UP)         # buton GP14 ile GND arasında / button between GP14 and GND
8
9hizli = False
10son_basma = 0
11son_degisim = time.ticks_ms()
12
13def buton_kesme(pin):                        # kesme fonksiyonu kısa olmalı / keep the handler short
14    global hizli, son_basma
15    simdi = time.ticks_ms()
16    if time.ticks_diff(simdi, son_basma) > 200:   # 200 ms debounce / 200 ms debounce
17        son_basma = simdi
18        hizli = not hizli
19
20buton.irq(trigger=Pin.IRQ_FALLING, handler=buton_kesme)   # basınca HIGH'dan LOW'a iner / goes HIGH to LOW when pressed
21
22while True:
23    aralik = 100 if hizli else 500
24    if time.ticks_diff(time.ticks_ms(), son_degisim) >= aralik:   # taşmaya karşı güvenli / safe against wrap-around
25        son_degisim = time.ticks_ms()
26        led.value(not led.value())
27    # burada başka işler yapılabilir / other work can run here

PWM : luminosité, servos et son

1# PWM: LED parlaklığı ve servo açısı / PWM: LED brightness and servo angle
2from machine import Pin, PWM
3import time
4
5led = PWM(Pin(15))
6led.freq(1000)                               # 1 kHz: titreme görünmez / no visible flicker
7
8for d in range(0, 65536, 2048):              # duty_u16: 0 (kapalı) ... 65535 (tam) / 0 (off) ... 65535 (full)
9    led.duty_u16(d)
10    time.sleep_ms(20)
11led.duty_u16(0)
12
13servo = PWM(Pin(16))
14servo.freq(50)                               # servolar 50 Hz (20 ms) ister / servos expect 50 Hz (20 ms)
15
16def servo_aci(derece):
17    us = 500 + derece * 2000 // 180          # 0° = 0,5 ms, 180° = 2,5 ms; servona göre ayarla / tune for your servo
18    servo.duty_ns(us * 1000)
19
20for a in (0, 90, 180, 90):
21    servo_aci(a)
22    time.sleep(1)

L'objet PWM allume et éteint une broche très vite pour régler une puissance moyenne. freq() fixe le nombre de répétitions par seconde et duty_u16() la durée pendant laquelle la broche reste allumée, avec un nombre entre 0 et 65535 ; 32768 correspond à environ 50 %. Cette échelle offre des pas bien plus fins que la plage 0–255 de analogWrite sur Arduino. Les servos attendent un signal à 50 Hz et une largeur d'impulsion entre 0,5 et 2,5 ms ; duty_ns() donne la durée de l'impulsion directement en nanosecondes, ce qui simplifie beaucoup le code du servo. Tu peux aussi jouer des notes en donnant différentes valeurs de freq() à un buzzer passif. Le rapport cyclique et la fréquence sont détaillés dans Qu'est-ce que la PWM.

ADC : lecture analogique

1# ADC: potansiyometre ve Pico'nun dahili sıcaklık sensörü
2# ADC: a potentiometer and the Pico's internal temperature sensor
3from machine import ADC, Pin
4import time
5
6pot = ADC(Pin(26))                           # GP26 = ADC0; ESP32'de ADC(Pin(34)) / ADC(Pin(34)) on ESP32
7yonga = ADC(4)                               # 4. kanal: dahili sıcaklık / channel 4: internal temperature
8
9def ortalama(adc, n=16):                     # gürültüyü azalt / reduce noise
10    toplam = 0
11    for _ in range(n):
12        toplam += adc.read_u16()
13    return toplam // n
14
15while True:
16    ham = ortalama(pot)                      # 0-65535 (12 bit ölçüm 16 bite ölçeklenir) / 12-bit reading scaled to 16 bits
17    volt = ham * 3.3 / 65535
18    v_t = ortalama(yonga) * 3.3 / 65535
19    derece = 27 - (v_t - 0.706) / 0.001721   # RP2040 veri sayfasındaki formül / formula from the RP2040 datasheet
20    print("Pot: {} ({:.2f} V)  Yonga / chip: {:.1f} C".format(ham, volt, derece))
21    time.sleep(1)

read_u16() renvoie une valeur entre 0 et 65535 sur toutes les cartes, donc le même code fonctionne sur la Pico et sur l'ESP32. L'ADC de la Pico est en réalité sur 12 bits et la mesure est mise à l'échelle sur 16 bits. La Pico dispose de trois broches analogiques accessibles : GP26 (ADC0), GP27 (ADC1) et GP28 (ADC2) ; le quatrième canal est le capteur de température interne de la puce et mesure la température de la puce, pas celle de la pièce. Sur l'ESP32, il faut adc.atten(ADC.ATTN_11DB) pour lire toute la plage 0–3,3 V, et les broches ADC2 sont inutilisables quand le Wi-Fi est actif ; choisis donc les broches ADC1 entre GPIO 32 et 39. La moyenne sur 16 mesures du code réduit nettement le bruit de l'ADC. Les notions de résolution et de tension de référence sont expliquées dans Qu'est-ce qu'un ADC.

I2C : brancher capteurs et écrans

1# I2C: hattı tara ve SSD1306 OLED'e yaz / I2C: scan the bus and write to an SSD1306 OLED
2from machine import Pin, I2C
3import ssd1306                               # önce: mpremote mip install ssd1306 / first: mpremote mip install ssd1306
4
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)   # Pico; ESP32'de I2C(0, sda=Pin(21), scl=Pin(22))
6adresler = i2c.scan()
7print("Bulunan / found:", [hex(a) for a in adresler])   # OLED genelde 0x3c / OLED is usually 0x3c
8
9if 0x3C in adresler:
10    oled = ssd1306.SSD1306_I2C(128, 64, i2c)
11    oled.fill(0)
12    oled.text("MicroPython", 0, 0)
13    oled.text("I2C: " + hex(adresler[0]), 0, 16)
14    oled.show()

I2C(0, sda=..., scl=...) démarre l'unité I2C matérielle sur les broches choisies et scan() renvoie la liste des adresses de tous les périphériques qui répondent sur le bus. Si un capteur ne fonctionne pas, ce scan est la première chose à faire : une liste vide signale un problème de câblage, et une adresse inattendue se corrige dans le code. Sur la Pico, les broches utilisables par chaque unité I2C sont fixes ; par exemple, les paires GP0-GP1, GP4-GP5 ou GP8-GP9 conviennent pour I2C0, et une mauvaise paire provoque une ValueError. Sur l'ESP32, l'I2C peut être affecté à presque n'importe quelle broche. Les détails de l'écran sont dans Écran OLED, et le protocole lui-même dans Qu'est-ce que l'I2C.

main.py et boot.py : le code qui s'exécute au démarrage

Quand tu appuies sur Exécuter dans Thonny, le code tourne seulement à cet instant sans être enregistré sur la carte ; il disparaît dès que tu débranches l'USB. Pour que ton code s'exécute tout seul à chaque démarrage, tu dois enregistrer le fichier sur la carte sous le nom main.py. Au démarrage, boot.py s'exécute d'abord, puis main.py. boot.py sert aux préparations ponctuelles comme la connexion Wi-Fi ou le réglage de l'horloge ; le firmware de l'ESP32 crée ce fichier lui-même, alors que sur la Pico il n'existe généralement pas. Ton vrai programme se trouve toujours dans main.py. Tu peux appeler dans main.py des fonctions écrites dans d'autres fichiers avec import et enregistrer des mesures dans le système de fichiers de la carte avec open().

1# main.py: kart her açıldığında otomatik çalışır / runs automatically every time the board starts
2import time
3from machine import Pin
4
5time.sleep(3)                                # Ctrl+C ile durdurmak için güvenlik payı / a safety window for Ctrl+C
6led = Pin("LED", Pin.OUT)
7sayac = 0
8
9try:
10    while True:
11        sayac += 1
12        led.value(sayac % 2)
13        print("Calisiyor / running", sayac)
14        time.sleep(1)
15except KeyboardInterrupt:                    # Thonny'de Stop ya da Ctrl+C / Stop in Thonny or Ctrl+C
16    led.value(0)
17    print("Durduruldu / stopped")

Envoyer des fichiers : Thonny et mpremote

Si tu débutes, Thonny est la solution la plus simple : écris ton code, choisis Fichier > Enregistrer sous, sélectionne Raspberry Pi Pico ou MicroPython device dans la fenêtre qui s'ouvre et nomme le fichier main.py. En ouvrant Affichage > Fichiers, tu vois côte à côte les fichiers de l'ordinateur et ceux de la carte, et tu copies de l'un à l'autre par un clic droit. Pour ceux qui aiment la ligne de commande et utilisent un éditeur comme VS Code, l'outil officiel est mpremote ; il s'installe avec pip install mpremote et se connecte automatiquement à la première carte MicroPython trouvée.

Ajouter des bibliothèques : mip

MicroPython n'a pas de pip ; on utilise à la place le petit gestionnaire de paquets mip. Sur une carte capable d'aller sur internet, comme la Pico W ou l'ESP32, tu te connectes d'abord au Wi-Fi puis tu tapes import mip et mip.install("ssd1306") dans le REPL ; le paquet est téléchargé depuis le dépôt officiel micropython-lib et placé dans le dossier /lib de la carte. Tu peux aussi installer un pilote depuis GitHub avec mip.install("github:utilisateur/depot"). Pour une Pico sans Wi-Fi, fais la même chose depuis l'ordinateur avec la commande mpremote mip install ou le menu Outils > Gérer les paquets de Thonny. Copier sur la carte un pilote d'un seul fichier (par exemple un .py écrit pour un capteur) suffit aussi ; tant que le fichier se trouve à la racine ou dans /lib, tu le charges avec import. Les étapes de connexion Wi-Fi sont dans Wi-Fi avec la Pico W.

MicroPython ou Arduino C++ ?

En pratique, c'est ton projet qui décide. Lire un capteur et l'envoyer en Wi-Fi, servir une page web ou piloter un écran se fait en moins de lignes et plus vite en MicroPython. Générer des signaux à la microseconde près, rafraîchir des centaines de LED très rapidement ou n'avoir qu'une petite carte comme l'Uno fait pencher la balance vers le C++. Tu peux accélérer une fonction lente avec le décorateur @micropython.native et réduire les pauses du ramasse-miettes en évitant de créer de nouvelles listes et chaînes dans les boucles. Pour choisir ta carte, vois aussi Arduino ou ESP32.

Erreurs fréquentes et solutions

MicroPython est le chemin le plus court vers le monde des microcontrôleurs quand on connaît déjà Python : tu vois le résultat dès que tu testes une broche dans le REPL, et quelques lignes suffisent pour lire un capteur et te connecter au Wi-Fi. Une fois les modules de base, le principe de main.py et la mesure du temps sans blocage avec ticks_ms maîtrisés, tes projets grandissent vite. Dans l'application BlueGrays, tu trouveras des projets Raspberry Pi Pico avec LED, feu tricolore, boutons et PWM, avec schémas de câblage et code MicroPython étape par étape.