MicroPythons interaktiva tolkläge (även kallat REPL)

Det här avsnittet beskriver några egenskaper hos MicroPythons interaktiva tolkläge. En vanligt förekommande term för detta är REPL (read-eval-print-loop), som kommer att användas för att hänvisa till denna interaktiva prompt.

Anteckning

OpenMV Cam exponerar denna REPL över sin USB-seriella (CDC) port. Den är endast relevant när du ansluter direkt till kameran med en seriell terminalemulator (eller ett verktyg som MicroPython fjärrstyrning: mpremote). OpenMV IDE använder inte REPL — det kommunicerar med kameran över ett separat felsökningsprotokoll för att köra skript, överföra filer och strömma bildbufferten. Allt som beskrivs på denna sida gäller endast direkta terminalsessioner.

Automatisk indentering

När du skriver Python-satser som slutar med ett kolon (till exempel if, for, while) ändras prompten till tre punkter (…) och markören indenteras med 4 mellanslag. När du trycker på retur fortsätter nästa rad på samma indenteringsnivå för vanliga satser, eller på en ytterligare indenteringsnivå där det är lämpligt. Om du trycker på backstegstangenten ångras en indenteringsnivå.

Om markören är hela vägen tillbaka vid början kommer ett tryck på RETURN att exekvera koden du har matat in. Följande visar vad du skulle se efter att ha matat in en for-sats (understrecket visar var markören hamnar):

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

Om du sedan matar in en if-sats läggs en ytterligare indenteringsnivå till:

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

Skriv nu break följt av RETURN och tryck på BACKSPACE:

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

Skriv slutligen print(i), tryck på RETURN, tryck på BACKSPACE och tryck på RETURN igen:

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

Automatisk indentering tillämpas inte om de två föregående raderna enbart bestod av mellanslag. Detta innebär att du kan avsluta inmatningen av en sammansatt sats genom att trycka på RETURN två gånger, och ett tredje tryck avslutar och exekverar.

Automatisk komplettering

När du skriver ett kommando vid REPL:n och raden du skrivit hittills motsvarar början på namnet på något, kommer ett tryck på TAB att visa möjliga saker som kan matas in. Importera till exempel först modulen machine genom att mata in import machine och trycka på RETURN. Skriv sedan m och tryck på TAB, så ska det expanderas till machine. Mata in en punkt . och tryck på TAB igen. Du bör se något i stil med:

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

Ordet expanderas så mycket som möjligt tills det finns flera möjligheter. Skriv till exempel machine.Pin.PULL och tryck på TAB, så expanderas det till machine.Pin.PULL_. Ett andra tryck på TAB visar de möjliga expansionerna:

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

Avbryta ett program som körs

Du kan avbryta ett program som körs genom att trycka på Ctrl-C. Detta ger upphov till ett KeyboardInterrupt som tar dig tillbaka till REPL:n, förutsatt att ditt program inte fångar upp undantaget KeyboardInterrupt.

Till exempel:

>>> 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:
>>>

Inklistringsläge

Om du vill klistra in kod i ditt terminalfönster kommer funktionen för automatisk indentering att ställa till det. Om du till exempel hade följande Python-kod:

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

och du försöker klistra in detta i den vanliga REPL:n kommer du att se något i stil med detta:

>>> 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

Om du trycker på Ctrl-E går du in i inklistringsläget, vilket i praktiken stänger av funktionen för automatisk indentering och ändrar prompten från >>> till ===. Till exempel:

>>>
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
>>>

Inklistringsläget tillåter att tomma rader klistras in. Den inklistrade texten kompileras som om den vore en fil. Ett tryck på Ctrl-D avslutar inklistringsläget och startar kompileringen.

Mjuk återställning

En Mjuk återställning återställer Python-tolken, men försöker att inte återställa metoden som du är ansluten till OpenMV Cam med (USB).

Du kan utföra en mjuk återställning från REPL:n genom att trycka på Ctrl-D, eller från din Python-kod genom att exekvera:

machine.soft_reset()

Om du till exempel återställer din OpenMV Cam och exekverar ett dir()-kommando skulle du se något i stil med detta:

>>> dir()
['__name__']

Skapa nu några variabler och upprepa dir()-kommandot:

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

Om du nu matar in Ctrl-D och upprepar dir()-kommandot ser du att dina variabler inte längre existerar:

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__']
>>>

Mer information om återställningstyper och uppstartsprocessen finns i Återställnings- och startsekvens.

Specialvariabeln _ (understreck)

När du använder REPL:n kan du utföra beräkningar och se resultaten. MicroPython lagrar resultatet av den föregående satsen i variabeln _ (understreck). Du kan alltså använda understrecket för att spara resultatet i en variabel. Till exempel:

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

Råläge och rå-inklistringsläge

Råläge (även kallat rå REPL) är inget en person normalt skulle använda. Det är avsett för programmatisk användning och beter sig i princip som inklistringsläget med eko avstängt och med valfri flödeskontroll.

Råläget öppnas med Ctrl-A. Du skickar sedan din Python-kod, följt av ett Ctrl-D. Ctrl-D kvitteras med ’OK’ och därefter kompileras och exekveras Python-koden. All utdata (eller fel) skickas tillbaka. Att mata in Ctrl-B lämnar råläget och återgår till den vanliga (även kallad vänliga) REPL:n.

Rå-inklistringsläge är ett ytterligare läge inom rå REPL som inkluderar flödeskontroll och som kompilerar kod allteftersom den tas emot. Detta gör det mer robust för höghastighetsöverföring av kod till enheten, och det använder även mindre RAM vid mottagning eftersom det inte behöver lagra en ordagrann kopia av koden innan kompilering (till skillnad från standardrådläget).

Rå-inklistringsläge använder följande protokoll:

  1. Öppna rå REPL som vanligt via ctrl-A.

  2. Skriv 3 byte: b"\x05A\x01" (dvs. ctrl-E, sedan ”A”, sedan ctrl-A).

  3. Läs 2 byte för att avgöra om enheten gick in i rå-inklistringsläge:

    • Om resultatet är b"R\x00" förstår enheten kommandot men har inte stöd för rå inklistring.

    • Om resultatet är b"R\x01" har enheten stöd för rå inklistring och har gått in i detta läge.

    • I annat fall bör resultatet vara b"ra", varvid enheten inte har stöd för rå inklistring, och strängen b"w REPL; CTRL-B to exit\r\n>" bör läsas och kasseras.

  4. Om enheten är i rå-inklistringsläge, fortsätt; återgå annars till standardrådläget.

  5. Läs 2 byte; detta är flödeskontrollens fönsterstorleksökning (i byte) lagrad som ett 16-bitars osignerat little-endian-heltal. Initialvärdet för variabeln för återstående fönsterstorlek bör sättas till detta tal.

  6. Skriv ut koden till enheten:

    • Så länge det finns byte att skicka, skriv upp till så många byte som motsvarar den återstående fönsterstorleken, och minska den återstående fönsterstorleken med antalet skrivna byte.

    • Om den återstående fönsterstorleken är 0, eller om det finns en byte som väntar på att läsas, läs 1 byte. Om denna byte är b"\x01" ökar du den återstående fönsterstorleken med fönsterstorleksökningen från steg 5. Om denna byte är b"\x04" vill enheten avsluta datamottagningen, och b"\x04" bör skrivas till enheten varefter ingen mer kod skickas. (Obs: om det finns en byte som väntar på att läsas från enheten behöver den inte läsas och hanteras omedelbart; enheten fortsätter att konsumera inkommande byte så länge den återstående fönsterstorleken är större än 0.)

  7. När all kod har skrivits till enheten, skriv b"\x04" för att markera slutet på data.

  8. Läs från enheten tills b"\x04" tas emot. Vid denna punkt har enheten tagit emot och kompilerat all kod som skickades och exekverar den.

  9. Enheten skriver ut alla tecken som produceras av koden som körs. När (om) koden avslutas skrivs b"\x04" ut, följt av eventuellt ofångat undantag, följt återigen av b"\x04". Den återgår sedan till standard rå REPL och skriver ut b">".

Om du till exempel börjar på en ny rad vid den normala (vänliga) REPL:n och skriver:

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

kommer enheten att svara med något i stil med:

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

Uppdelat över tid ser detta ut så här:

# 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>"

I detta fall är flödeskontrollens fönsterstorleksökning 128 och det finns två fönster med data omedelbart tillgängliga vid starten, ett från det initiala värdet för fönsterstorleksökningen och ett från det explicita värdet b"\x01" som skickas. Detta innebär alltså att upp till 256 byte kan skrivas till att börja med innan man väntar på eller kontrollerar fler inkommande flödeskontrolltecken.

Verktyget MicroPython fjärrstyrning: mpremote använder rå REPL, inklusive rå-inklistringsläge, för att exekvera Python-kod på OpenMV Cam.