MicroPython 1 :
Pico et ESP32.

1. Pico : maintenir BOOTSEL, brancher l’USB, relâcher. Un disque « RPI-RP2 » apparaît. Y glisser le fichier .uf2 de micropython.org. La carte redémarre.
2. ESP32 : dans Thonny, Outils → Options → Interpréteur → « Installer ou mettre à jour MicroPython », choisir le port et la famille ESP32.
3. Thonny : Interpréteur → « MicroPython (Raspberry Pi Pico) » ou « (ESP32) », port automatique.
4. Dans la console (REPL) en bas, taper print("bonjour"). La carte répond.

>>> import sys
>>> sys.implementation
(name='micropython', version=(1, 22, 0), ...)
>>> import gc
>>> gc.mem_free()
187456                    # octets de RAM libres
>>> from machine import Pin
>>> led = Pin("LED", Pin.OUT)   # Pico ; Pin(2) sur ESP32
>>> led.on()
>>> led.off()
>>> led.toggle()

Le REPL exécute chaque ligne sur la carte, immédiatement. Pas de compilation, pas de téléversement : essayer, voir, corriger.

# Version 1 : avec sleep (bloquant)
from machine import Pin
import time

led = Pin("LED", Pin.OUT)      # Pico W : "LED" ; Pico : 25 ; ESP32 : 2
while True:
    led.toggle()
    time.sleep(0.5)

# Version 2 : avec l'horloge (non bloquant)
from machine import Pin
import time

led = Pin("LED", Pin.OUT)
prochain = time.ticks_ms()
while True:
    if time.ticks_diff(time.ticks_ms(), prochain) >= 0:
        led.toggle()
        prochain = time.ticks_add(prochain, 500)
    # ... autres tâches ...

# Version 3 : avec un Timer matériel
from machine import Pin, Timer

led = Pin("LED", Pin.OUT)
Timer(period=500, mode=Timer.PERIODIC,
      callback=lambda t: led.toggle())
# Le programme principal est libre : le timer
# appelle la fonction tout seul, comme une
# interruption. Sur ESP32 : Timer(0, ...)

while True:
    pass          # ou tout autre travail

ticks_ms() déborde après 2³⁰ ms : ticks_diff et ticks_add gèrent le débordement correctement (séance 13). Ne jamais soustraire directement.

from machine import Pin, ADC, PWM
import time

# Bouton avec rappel interne : pressé = 0
bouton = Pin(14, Pin.IN, Pin.PULL_UP)
print(bouton.value())

# Entrée analogique : 16 bits (0..65535) sur Pico,
# quelle que soit la résolution réelle (12 bits)
pot = ADC(26)                    # GP26 = ADC0 ; ESP32 : ADC(Pin(34))
brut = pot.read_u16()
tension = brut * 3.3 / 65535
print(brut, round(tension, 2), "V")

# PWM : fréquence et rapport cyclique 16 bits
led = PWM(Pin(15))
led.freq(1000)
led.duty_u16(32768)              # 50 %
# ESP32 : led.duty(512) sur 10 bits, ou duty_u16 selon la version

# Servo : PWM 50 Hz, impulsion 1-2 ms
from machine import Pin, PWM
servo = PWM(Pin(16)); servo.freq(50)

def angle(deg):
    # 1 ms = 5 % de 20 ms ; 2 ms = 10 %
    largeur = 1.0 + deg / 180.0          # ms
    servo.duty_u16(int(largeur / 20.0 * 65535))

angle(0); time.sleep(1); angle(180)

# Ultrason HC-SR04 (avec diviseur sur ECHO !)
from machine import time_pulse_us
trig, echo = Pin(17, Pin.OUT), Pin(18, Pin.IN)
def distance_cm():
    trig.off(); time.sleep_us(2)
    trig.on(); time.sleep_us(10); trig.off()
    d = time_pulse_us(echo, 1, 30000)  # µs, -1 ou -2 si timeout
    return d * 0.01715 if d > 0 else None

# Interruption : compter les impulsions d'un encodeur
from machine import Pin
impulsions = 0

def isr(pin):
    global impulsions
    impulsions += 1              # court, pas d'allocation

enc = Pin(19, Pin.IN, Pin.PULL_UP)
enc.irq(handler=isr, trigger=Pin.IRQ_FALLING)

import time
while True:
    time.sleep(1)
    n, impulsions = impulsions, 0
    print(n, "impulsions/s")

Dans une ISR MicroPython : pas de création d’objets (listes, chaînes, float), pas de print. Pour du travail plus lourd, micropython.schedule(f, arg) reporte l’exécution dans la boucle principale.

• La carte a un petit système de fichiers (1–2 Mo). Thonny → Affichage → Fichiers montre « Cet ordinateur » et « Raspberry Pi Pico ».
• boot.py s’exécute au démarrage (config, WiFi). main.py ensuite : c’est votre programme autonome, lancé sans PC.
• Vos modules (capteurs.py, moteurs.py) se copient sur la carte et s’importent normalement (séance 09).
• Un fichier de journal s’écrit avec open() comme en séance 07, dans la flash.

Pour reprendre la main sur une carte dont main.py boucle : Ctrl+C dans Thonny, puis supprimer ou renommer main.py.

# main.py : structure d'un programme de robot
from machine import Pin, Timer
import time, capteurs, moteurs

led = Pin("LED", Pin.OUT)
Timer(period=250, mode=Timer.PERIODIC, callback=lambda t: led.toggle())   # « je suis vivant »

def cycle():
    d = capteurs.distance()
    if d is not None and d < 20:
        moteurs.tourner(50)
    else:
        moteurs.avancer(80)

try:
    prochain = time.ticks_ms()
    while True:
        cycle()
        prochain = time.ticks_add(prochain, 50)
        time.sleep_ms(max(0, time.ticks_diff(prochain, time.ticks_ms())))
except KeyboardInterrupt:
    pass
finally:
    moteurs.stop()          # toujours, même sur Ctrl+C (séance 08)