La modalità interprete interattivo di MicroPython (detta REPL)

Questa sezione illustra alcune caratteristiche della modalità interprete interattivo di MicroPython. Un termine comunemente usato per indicarla è REPL (read-eval-print-loop), che useremo per riferirci a questo prompt interattivo.

Nota

Le OpenMV Cam espongono questo REPL tramite la loro porta seriale USB (CDC). È rilevante solo quando ci si connette direttamente alla camera con un emulatore di terminale seriale (o con uno strumento come Controllo remoto di MicroPython: mpremote). OpenMV IDE non usa il REPL — comunica con la camera tramite un protocollo di debug separato per eseguire script, trasferire file e fare lo streaming del framebuffer. Tutto ciò che è descritto in questa pagina si applica esclusivamente alle sessioni di terminale dirette.

Auto-indentazione

Quando si digitano istruzioni Python che terminano con i due punti (per esempio if, for, while), il prompt cambia in tre punti (…) e il cursore viene indentato di 4 spazi. Quando si preme invio, la riga successiva continua allo stesso livello di indentazione per le istruzioni normali, oppure a un livello di indentazione aggiuntivo dove appropriato. Premendo il tasto backspace si annulla un livello di indentazione.

Se il cursore si trova all’inizio della riga, premendo INVIO viene eseguito il codice che è stato inserito. Quanto segue mostra ciò che si vedrebbe dopo aver inserito un’istruzione for (il trattino basso indica dove finisce il cursore):

>>> for i in range(30):
...     _

Se si inserisce poi un’istruzione if, viene fornito un livello di indentazione aggiuntivo:

>>> for i in range(30):
...     if i > 3:
...         _

Ora inserisci break seguito da INVIO e premi BACKSPACE:

>>> for i in range(30):
...     if i > 3:
...         break
...     _

Infine digita print(i), premi INVIO, premi BACKSPACE e premi di nuovo INVIO:

>>> for i in range(30):
...     if i > 3:
...         break
...     print(i)
...
0
1
2
3
>>>

L’auto-indentazione non viene applicata se le due righe precedenti erano composte solo da spazi. Questo significa che è possibile terminare l’inserimento di un’istruzione composta premendo INVIO due volte, e una terza pressione completerà ed eseguirà.

Auto-completamento

Mentre si digita un comando al REPL, se la riga digitata fino a quel momento corrisponde all’inizio del nome di qualcosa, premendo TAB verranno mostrate le possibili voci che potrebbero essere inserite. Per esempio, importa prima il modulo machine inserendo import machine e premendo INVIO. Poi digita m e premi TAB: dovrebbe espandersi in machine. Inserisci un punto . e premi di nuovo TAB. Dovresti vedere qualcosa come:

>>> machine.
__name__        info            unique_id       reset
bootloader      freq            rng             idle
sleep           deepsleep       disable_irq     enable_irq
Pin

La parola verrà espansa il più possibile finché non esistono più possibilità. Per esempio, digita machine.Pin.PULL e premi TAB: si espanderà in machine.Pin.PULL_. Premendo TAB una seconda volta verranno mostrate le possibili espansioni:

>>> machine.Pin.PULL_
PULL_DOWN       PULL_UP
>>> machine.Pin.PULL_

Interrompere un programma in esecuzione

Puoi interrompere un programma in esecuzione premendo Ctrl-C. Questo solleverà una KeyboardInterrupt che ti riporterà al REPL, a condizione che il tuo programma non intercetti l’eccezione KeyboardInterrupt.

Per esempio:

>>> for i in range(1000000):
...     print(i)
...
0
1
2
3
...
6466
6467
6468
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
KeyboardInterrupt:
>>>

Modalità incolla (paste mode)

Se vuoi incollare del codice nella finestra del terminale, la funzione di auto-indentazione causerà dei problemi. Per esempio, se avessi il seguente codice Python:

def foo():
    print('This is a test to show paste mode')
    print('Here is a second line')
foo()

e provassi a incollarlo nel normale REPL, vedresti qualcosa come questo:

>>> def foo():
...         print('This is a test to show paste mode')
...             print('Here is a second line')
...             foo()
...
Traceback (most recent call last):
  File "<stdin>", line 3
IndentationError: unexpected indent

Se premi Ctrl-E, entrerai in modalità incolla, che essenzialmente disattiva la funzione di auto-indentazione e cambia il prompt da >>> a ===. Per esempio:

>>>
paste mode; Ctrl-C to cancel, Ctrl-D to finish
=== def foo():
===     print('This is a test to show paste mode')
===     print('Here is a second line')
=== foo()
===
This is a test to show paste mode
Here is a second line
>>>

La modalità incolla consente di incollare righe vuote. Il testo incollato viene compilato come se fosse un file. Premendo Ctrl-D si esce dalla modalità incolla e si avvia la compilazione.

Soft reset

Un Soft reset reimposta l’interprete Python, ma cerca di non reimpostare il metodo con cui si è connessi alla OpenMV Cam (USB).

Puoi eseguire un soft reset dal REPL premendo Ctrl-D, oppure dal tuo codice Python eseguendo:

machine.soft_reset()

Per esempio, se reimposti la tua OpenMV Cam ed esegui un comando dir(), vedresti qualcosa come questo:

>>> dir()
['__name__']

Ora crea alcune variabili e ripeti il comando dir():

>>> i = 1
>>> j = 23
>>> x = 'abc'
>>> dir()
['j', 'x', '__name__', 'i']
>>>

Ora, se premi Ctrl-D e ripeti il comando dir(), vedrai che le tue variabili non esistono più:

MPY: sync filesystems
MPY: soft reboot
MicroPython v1.25.0 on 2025-05-15; OpenMV Cam H7 with STM32H743
Type "help()" for more information.
>>> dir()
['__name__']
>>>

Per maggiori informazioni sui tipi di reset e sul processo di avvio, vedi Sequenza di reset e avvio.

La variabile speciale _ (trattino basso)

Quando usi il REPL, puoi eseguire calcoli e vederne i risultati. MicroPython memorizza il risultato dell’istruzione precedente nella variabile _ (trattino basso). Puoi quindi usare il trattino basso per salvare il risultato in una variabile. Per esempio:

>>> 1 + 2 + 3 + 4 + 5
15
>>> x = _
>>> x
15
>>>

Modalità raw e modalità raw-paste

La modalità raw (chiamata anche raw REPL) non è qualcosa che una persona userebbe normalmente. È pensata per l’uso programmatico e si comporta essenzialmente come la modalità incolla con l’eco disattivato e con un controllo di flusso opzionale.

Si entra nella modalità raw usando Ctrl-A. Si invia quindi il proprio codice python, seguito da un Ctrl-D. Il Ctrl-D verrà confermato con “OK” e poi il codice python verrà compilato ed eseguito. Qualsiasi output (o errore) verrà rispedito indietro. Premendo Ctrl-B si esce dalla modalità raw e si torna al REPL normale (detto anche friendly).

La modalità raw-paste è una modalità aggiuntiva all’interno del raw REPL che include il controllo di flusso e che compila il codice man mano che lo riceve. Questo la rende più robusta per il trasferimento ad alta velocità del codice nel dispositivo, e usa anche meno RAM durante la ricezione perché non ha bisogno di memorizzare una copia letterale del codice prima di compilarlo (a differenza della modalità raw standard).

La modalità raw-paste usa il seguente protocollo:

  1. Entrare nel raw REPL come al solito tramite ctrl-A.

  2. Scrivere 3 byte: b"\x05A\x01" (ovvero ctrl-E poi «A» poi ctrl-A).

  3. Leggere 2 byte per determinare se il dispositivo è entrato in modalità raw-paste:

    • Se il risultato è b"R\x00" allora il dispositivo comprende il comando ma non supporta il raw paste.

    • Se il risultato è b"R\x01" allora il dispositivo supporta il raw paste ed è entrato in questa modalità.

    • Altrimenti il risultato dovrebbe essere b"ra" e il dispositivo non supporta il raw paste, e la stringa b"w REPL; CTRL-B to exit\r\n>" dovrebbe essere letta e scartata.

  4. Se il dispositivo è in modalità raw-paste allora si continua, altrimenti si ricade nella modalità raw standard.

  5. Leggere 2 byte: questo è l’incremento della dimensione della finestra di controllo di flusso (in byte) memorizzato come intero senza segno a 16 bit little endian. Il valore iniziale della variabile remaining-window-size dovrebbe essere impostato a questo numero.

  6. Scrivere il codice sul dispositivo:

    • Finché ci sono byte da inviare, scrivere fino a un numero di byte pari al remaining-window-size, e diminuire il remaining-window-size del numero di byte scritti.

    • Se il remaining-window-size è 0, oppure c’è un byte in attesa di essere letto, leggere 1 byte. Se questo byte è b"\x01" allora aumentare il remaining-window-size dell’incremento della dimensione della finestra dal passo 5. Se questo byte è b"\x04" allora il dispositivo vuole terminare la ricezione dei dati, e b"\x04" dovrebbe essere scritto sul dispositivo e nessun altro codice inviato dopo di esso. (Nota: se c’è un byte in attesa di essere letto dal dispositivo, non è necessario leggerlo e agire immediatamente; il dispositivo continuerà a consumare i byte in arrivo finché il remaining-window-size è maggiore di 0.)

  7. Quando tutto il codice è stato scritto sul dispositivo, scrivere b"\x04" per indicare la fine dei dati.

  8. Leggere dal dispositivo finché non viene ricevuto b"\x04". A questo punto il dispositivo ha ricevuto e compilato tutto il codice che è stato inviato e lo sta eseguendo.

  9. Il dispositivo emette qualsiasi carattere prodotto dal codice in esecuzione. Quando (se) il codice termina, verrà emesso b"\x04", seguito da qualsiasi eccezione non gestita, seguito di nuovo da b"\x04". Torna quindi al raw REPL standard ed emette b">".

Per esempio, partendo da una nuova riga al REPL normale (friendly), se scrivi:

b"\x01\x05A\x01print(123)\x04"

Allora il dispositivo risponderà con qualcosa come:

b"\r\nraw REPL; CTRL-B to exit\r\n>R\x01\x80\x00\x01\x04123\r\n\x04\x04>"

Suddiviso nel tempo, questo appare così:

# Step 1: enter raw REPL
write: b"\x01"
read: b"\r\nraw REPL; CTRL-B to exit\r\n>"

# Step 2-5: enter raw-paste mode
write: b"\x05A\x01"
read: b"R\x01\x80\x00\x01"

# Step 6-8: write out code
write: b"print(123)\x04"
read: b"\x04"

# Step 9: code executes and result is read
read: b"123\r\n\x04\x04>"

In questo caso l’incremento della dimensione della finestra di controllo di flusso è 128 e ci sono due finestre di dati immediatamente disponibili all’inizio, una dal valore iniziale dell’incremento della dimensione della finestra e una dal valore esplicito b"\x01" che viene inviato. Questo significa che fino a 256 byte possono essere scritti all’inizio prima di dover attendere o controllare la presenza di altri caratteri di controllo di flusso in arrivo.

Lo strumento Controllo remoto di MicroPython: mpremote usa il raw REPL, inclusa la modalità raw-paste, per eseguire codice Python sulle OpenMV Cam.