Cos'è MicroPython? Comandi base, REPL e primi programmi

MicroPython è una reimplementazione piccola e veloce del linguaggio Python 3 per i microcontrollori. Quando installi MicroPython su una scheda come il Raspberry Pi Pico o l'ESP32, la scheda esegue da sola il codice Python: scrivi un comando senza compilare nulla e vedi subito il LED accendersi. Se hai imparato Python a scuola o sul computer, con la stessa sintassi puoi leggere pin, pilotare motori, raccogliere dati dai sensori e collegarti al Wi-Fi.

In questa guida scoprirai in cosa MicroPython differisce dal Python normale, il REPL che ti permette di parlare subito con la scheda e i moduli che userai di più, cioè machine.Pin, PWM, ADC e I2C, con codice di esempio. Poi vedrai la differenza tra time.sleep e ticks_ms, i file main.py e boot.py che partono all'avvio, il caricamento dei file con Thonny e mpremote, l'aggiunta di librerie con mip e l'installazione del firmware su Pico ed ESP32. Nell'ultima sezione mettiamo a confronto MicroPython e Arduino C++.

Cos'è MicroPython e in cosa differisce da Python?

MicroPython è un progetto open source avviato da Damien George nel 2013 per una piccola scheda e oggi supporta decine di microcontrollori. Il firmware che installi sulla scheda contiene l'interprete Python, i moduli di base e un piccolo file system. Il tuo codice viene prima trasformato in bytecode sulla scheda e poi l'interprete esegue quel bytecode passo dopo passo. Poiché è impossibile far entrare tutto il Python del computer in poche centinaia di KB di RAM, il linguaggio resta lo stesso, ma la maggior parte delle librerie è ridotta o del tutto assente. In cambio è stato aggiunto qualcosa che il Python per desktop non ha: il modulo machine, che dà accesso diretto all'hardware.

Schede che eseguono MicroPython

Installare il firmware MicroPython su Pico ed ESP32

1. Pico: Tieni premuto il pulsante BOOTSEL della scheda mentre colleghi il cavo USB, poi rilascialo. Sul computer compare un'unità chiamata RPI-RP2 (RP2350 sul Pico 2).
2. Scarica dalla pagina ufficiale di MicroPython il file .uf2 adatto alla tua scheda (RPI_PICO per il Pico, RPI_PICO_W per il Pico W) e trascinalo in quell'unità.
3. Finita la copia, la scheda si riavvia da sola e l'unità scompare; MicroPython è installato. In Thonny scegli MicroPython (Raspberry Pi Pico) in Strumenti > Opzioni > Interprete.
4. ESP32: Se sul computer hai Python, scrivi pip install esptool nella riga di comando. Collega la scheda e trova la sua porta (ad esempio COM3 su Windows, /dev/ttyUSB0 su Linux).
5. Cancella prima la flash: esptool.py --chip esp32 --port COM3 erase_flash. Se la scheda non si connette, tieni premuto il pulsante BOOT mentre il comando è in esecuzione.
6. Scrivi il firmware: esptool.py --chip esp32 --port COM3 --baud 460800 write_flash -z 0x1000 ESP32_GENERIC-....bin. Su ESP32-S3 ed ESP32-C3 l'indirizzo è 0x0. L'opzione Install or update MicroPython (esptool) di Thonny fa la stessa cosa da una finestra.

Il REPL: parlare subito con la scheda

Il REPL (Read-Eval-Print Loop) è la riga di comando che la scheda ti apre attraverso la porta seriale. Il simbolo >>> che vedi nella finestra Shell in basso in Thonny indica che il REPL ti sta aspettando. Se scrivi 1 + 1, la scheda calcola e restituisce 2; se scrivi from machine import Pin e poi Pin("LED", Pin.OUT).value(1), il LED del Pico si accende in quell'istante. Non c'è modo più rapido del REPL per leggere il valore di un sensore, verificare se un pin è collegato bene o scoprire come funziona una libreria, senza aspettare compilazione e caricamento.

Primo programma e il suo equivalente in 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}

I due programmi fanno la stessa cosa, ma la struttura è diversa. In MicroPython non esistono setup() e loop(): il file viene eseguito una volta dall'alto in basso e il ciclo infinito lo costruisci tu con while True:. Al posto di parentesi graffe e punti e virgola si usa l'indentazione; tutte le righe dentro il ciclo devono avere la stessa rientranza (di solito 4 spazi). Anche l'attesa usa un'altra unità: time.sleep(0.5) vuole i secondi, mentre delay(500) di Arduino vuole i millisecondi. In MicroPython si usano time.sleep_ms() per i millisecondi e time.sleep_us() per i microsecondi. Le basi del lato Arduino sono in Basi della programmazione Arduino.

machine.Pin: ingressi e uscite digitali

time.sleep e ticks_ms: misurare il tempo senza bloccare

time.sleep() mette la scheda completamente in attesa; nel frattempo nessun pulsante viene letto e nessun sensore viene controllato. Per gestire più compiti insieme si usa l'equivalente MicroPython della tecnica millis() di Arduino: time.ticks_ms() dà i millisecondi trascorsi dall'avvio e time.ticks_diff(nuovo, vecchio) calcola la differenza tra due istanti. È importante ottenere la differenza con ticks_diff e non con una sottrazione normale; il contatore ricomincia da capo dopo un certo valore e in quel momento la sottrazione dà un risultato sbagliato. Il codice seguente fa lampeggiare il LED senza bloccare e intanto ascolta un pulsante tramite un interrupt (IRQ); ogni pressione cambia la velocità del lampeggio.

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à, servo e suoni

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'oggetto PWM accende e spegne un pin molto velocemente per regolare una potenza media. freq() stabilisce quante volte al secondo si ripete e duty_u16() per quanto tempo il pin resta acceso, con un numero tra 0 e 65535; 32768 corrisponde a circa il 50 %. Questa scala offre passi molto più fini dell'intervallo 0–255 di analogWrite su Arduino. I servo si aspettano un segnale a 50 Hz e un impulso tra 0,5 e 2,5 ms; duty_ns() imposta la durata dell'impulso direttamente in nanosecondi e semplifica molto il codice del servo. Puoi anche suonare note dando a un buzzer passivo valori diversi di freq(). Duty cycle e frequenza sono spiegati nel dettaglio in Cos'è il PWM.

ADC: lettura analogica

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() restituisce un valore tra 0 e 65535 su tutte le schede, quindi lo stesso codice funziona su Pico ed ESP32. L'ADC del Pico è in realtà a 12 bit e la lettura viene scalata a 16 bit. Il Pico ha tre pin analogici accessibili: GP26 (ADC0), GP27 (ADC1) e GP28 (ADC2); il quarto canale è il sensore di temperatura interno del chip e misura la temperatura del chip, non quella della stanza. Sull'ESP32 serve adc.atten(ADC.ATTN_11DB) per leggere l'intero intervallo 0–3,3 V, e i pin ADC2 non si possono usare con il Wi-Fi attivo, quindi scegli i pin ADC1 tra GPIO 32 e 39. La media di 16 letture nel codice riduce sensibilmente il rumore dell'ADC. Concetti come risoluzione e tensione di riferimento sono in Cos'è un ADC.

I2C: collegare sensori e display

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=...) avvia l'unità I2C hardware sui pin scelti e scan() restituisce l'elenco degli indirizzi di tutti i dispositivi che rispondono sul bus. Se un sensore non funziona, questa scansione è la prima cosa da fare: un elenco vuoto indica un problema di collegamento, e un indirizzo diverso da quello atteso si corregge nel codice. Sul Pico i pin utilizzabili da ogni unità I2C sono fissi; per esempio per I2C0 funzionano le coppie GP0-GP1, GP4-GP5 o GP8-GP9, e scegliendo una coppia sbagliata ottieni un ValueError. Sull'ESP32 l'I2C si può assegnare a quasi tutti i pin. I dettagli del display sono in Display OLED e il protocollo in Cos'è l'I2C.

main.py e boot.py: il codice che parte all'avvio

Quando premi Esegui in Thonny, il codice gira solo in quel momento senza essere salvato sulla scheda; staccando l'USB sparisce. Perché il codice parta da solo a ogni accensione devi salvare il file sulla scheda con il nome main.py. All'avvio viene eseguito prima boot.py e poi main.py. boot.py serve per preparativi da fare una volta, come la connessione Wi-Fi o l'impostazione dell'orologio; il firmware dell'ESP32 crea questo file da solo, mentre sul Pico di solito non c'è. Il tuo programma vero e proprio sta sempre in main.py. Puoi richiamare in main.py funzioni scritte in altri file con import e salvare misure nel file system della scheda con 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")

Caricare i file: Thonny e mpremote

Se stai iniziando, Thonny è la strada più semplice: scrivi il codice, scegli File > Salva come, nella finestra che si apre seleziona Raspberry Pi Pico o MicroPython device e chiama il file main.py. Aprendo Visualizza > File vedi affiancati i file del computer e quelli della scheda, e li copi dall'uno all'altro con il tasto destro. Per chi ama la riga di comando e usa un editor come VS Code, lo strumento ufficiale è mpremote; si installa con pip install mpremote e si collega da solo alla prima scheda MicroPython che trova.

Aggiungere librerie: mip

In MicroPython non c'è pip; al suo posto si usa il piccolo gestore di pacchetti mip. Su una scheda che può andare su internet, come Pico W o ESP32, ti colleghi prima al Wi-Fi e poi scrivi nel REPL import mip e mip.install("ssd1306"); il pacchetto viene scaricato dal repository ufficiale micropython-lib e messo nella cartella /lib della scheda. Puoi installare anche un driver da GitHub con mip.install("github:utente/repository"). Per un Pico senza Wi-Fi fai la stessa cosa dal computer con il comando mpremote mip install o con il menu Strumenti > Gestisci pacchetti di Thonny. Anche copiare sulla scheda un driver di un solo file (ad esempio un .py scritto per un sensore) funziona; finché il file si trova nella radice o in /lib, lo carichi con import. I passaggi per collegarsi al Wi-Fi sono in Wi-Fi con il Pico W.

MicroPython o Arduino C++?

In pratica decide il tuo progetto. Leggere un sensore e inviarlo via Wi-Fi, servire una pagina web o pilotare un display richiede meno righe e si fa prima in MicroPython. Generare segnali con precisione al microsecondo, aggiornare centinaia di LED molto velocemente o avere solo una scheda piccola come la Uno fa pendere la bilancia verso il C++. Puoi accelerare una funzione lenta con il decoratore @micropython.native e ridurre le pause del garbage collector evitando di creare nuove liste e stringhe dentro i cicli. Per scegliere la scheda vedi anche Arduino o ESP32.

Errori comuni e soluzioni

MicroPython è la strada più breve verso il mondo dei microcontrollori se conosci già Python: vedi il risultato appena provi un pin nel REPL e con poche righe leggi un sensore e ti colleghi al Wi-Fi. Quando avrai imparato i moduli di base, l'idea di main.py e la temporizzazione senza blocchi con ticks_ms, i tuoi progetti cresceranno in fretta. Nell'app BlueGrays trovi progetti con il Raspberry Pi Pico con LED, semaforo, pulsanti e PWM, con schemi di collegamento e codice MicroPython passo passo.