Modul interpretor interactiv MicroPython (cunoscut și ca REPL)

Această secțiune prezintă unele caracteristici ale modului interpretor interactiv MicroPython. Un termen folosit în mod obișnuit pentru acesta este REPL (read-eval-print-loop), care va fi utilizat pentru a desemna acest prompt interactiv.

Notă

Camerele OpenMV Cam expun acest REPL prin portul lor serial USB (CDC). Este relevant doar atunci când vă conectați direct la cameră cu un emulator de terminal serial (sau un instrument precum Control la distanță MicroPython: mpremote). OpenMV IDE nu folosește REPL — comunică cu camera printr-un protocol de depanare separat pentru a rula scripturi, a transfera fișiere și a transmite tamponul de cadre (frame buffer). Tot ceea ce este descris pe această pagină se aplică numai sesiunilor directe de terminal.

Indentare automată

Atunci când tastați instrucțiuni Python care se termină cu două puncte (de exemplu if, for, while), promptul se va schimba în trei puncte (…) iar cursorul va fi indentat cu 4 spații. Când apăsați Return, linia următoare va continua la același nivel de indentare pentru instrucțiunile obișnuite sau la un nivel suplimentar de indentare acolo unde este cazul. Dacă apăsați tasta Backspace, se va anula un nivel de indentare.

Dacă cursorul este complet în partea stângă, la început, apăsarea tastei RETURN va executa codul pe care l-ați introdus. În continuare se arată ce ați vedea după introducerea unei instrucțiuni for (liniuța de subliniere indică unde ajunge cursorul):

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

Dacă introduceți apoi o instrucțiune if, va fi furnizat un nivel suplimentar de indentare:

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

Acum introduceți break urmat de RETURN și apăsați BACKSPACE:

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

În final tastați print(i), apăsați RETURN, apăsați BACKSPACE și apăsați din nou RETURN:

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

Indentarea automată nu se va aplica dacă precedentele două linii au fost formate doar din spații. Aceasta înseamnă că puteți finaliza introducerea unei instrucțiuni compuse apăsând RETURN de două ori, iar a treia apăsare va finaliza și va executa.

Completare automată

În timp ce tastați o comandă la REPL, dacă linia tastată până acum corespunde începutului numelui a ceva, atunci apăsarea TAB va afișa elementele posibile care ar putea fi introduse. De exemplu, importați mai întâi modulul machine introducând import machine și apăsând RETURN. Apoi tastați m și apăsați TAB, iar acesta ar trebui să se extindă în machine. Introduceți un punct . și apăsați din nou TAB. Ar trebui să vedeți ceva de genul:

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

Cuvântul va fi extins cât mai mult posibil până când există mai multe posibilități. De exemplu, tastați machine.Pin.PULL și apăsați TAB, iar acesta se va extinde în machine.Pin.PULL_. Apăsarea TAB a doua oară va afișa extinderile posibile:

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

Întreruperea unui program în execuție

Puteți întrerupe un program în execuție apăsând Ctrl-C. Aceasta va genera o excepție KeyboardInterrupt care vă va readuce la REPL, cu condiția ca programul dumneavoastră să nu intercepteze excepția KeyboardInterrupt.

De exemplu:

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

Modul lipire (paste)

Dacă doriți să lipiți cod în fereastra terminalului, funcția de indentare automată va strica lucrurile. De exemplu, dacă aveați următorul cod Python:

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

iar dacă încercați să lipiți acest cod în REPL-ul normal, atunci veți vedea ceva de genul:

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

Dacă apăsați Ctrl-E, atunci veți intra în modul lipire (paste), care practic dezactivează funcția de indentare automată și schimbă promptul din >>> în ===. De exemplu:

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

Modul lipire (paste) permite lipirea liniilor goale. Textul lipit este compilat ca și cum ar fi un fișier. Apăsarea Ctrl-D iese din modul lipire și inițiază compilarea.

Resetare software (soft reset)

O Resetare software va reseta interpretorul Python, dar încearcă să nu reseteze metoda prin care sunteți conectat la OpenMV Cam (USB).

Puteți efectua o resetare software de la REPL apăsând Ctrl-D, sau din codul dumneavoastră Python executând:

machine.soft_reset()

De exemplu, dacă resetați OpenMV Cam și executați o comandă dir(), ați vedea ceva de genul:

>>> dir()
['__name__']

Acum creați câteva variabile și repetați comanda dir():

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

Acum, dacă introduceți Ctrl-D și repetați comanda dir(), veți vedea că variabilele dumneavoastră nu mai există:

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

Pentru mai multe informații despre tipurile de resetare și procesul de pornire, consultați Secvența de resetare și pornire.

Variabila specială _ (liniuță de subliniere)

Când folosiți REPL, puteți efectua calcule și vedea rezultatele. MicroPython stochează rezultatul instrucțiunii precedente în variabila _ (liniuță de subliniere). Astfel, puteți folosi liniuța de subliniere pentru a salva rezultatul într-o variabilă. De exemplu:

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

Modul brut (raw) și modul brut-lipire (raw-paste)

Modul brut (numit și REPL brut) nu este ceva ce o persoană ar folosi în mod normal. Este destinat utilizării programatice și se comportă, în esență, ca modul lipire cu ecoul dezactivat și cu control opțional al fluxului.

Modul brut se accesează folosind Ctrl-A. Apoi trimiteți codul dumneavoastră Python, urmat de un Ctrl-D. Ctrl-D va fi confirmat prin «OK», după care codul Python va fi compilat și executat. Orice ieșire (sau erori) va fi trimisă înapoi. Introducerea Ctrl-B va părăsi modul brut și va reveni la REPL-ul obișnuit (cunoscut și ca prietenos).

Modul brut-lipire (raw-paste) este un mod suplimentar în cadrul REPL-ului brut care include control al fluxului și care compilează codul pe măsură ce îl primește. Acest lucru îl face mai robust pentru transferul de cod la viteză mare în dispozitiv și, de asemenea, folosește mai puțină memorie RAM la recepție, deoarece nu trebuie să stocheze o copie textuală a codului înainte de compilare (spre deosebire de modul brut standard).

Modul brut-lipire folosește următorul protocol:

  1. Intrați în REPL-ul brut ca de obicei prin ctrl-A.

  2. Scrieți 3 octeți: b"\x05A\x01" (adică ctrl-E, apoi „A”, apoi ctrl-A).

  3. Citiți 2 octeți pentru a determina dacă dispozitivul a intrat în modul brut-lipire:

    • Dacă rezultatul este b"R\x00" atunci dispozitivul înțelege comanda, dar nu acceptă lipirea brută.

    • Dacă rezultatul este b"R\x01" atunci dispozitivul acceptă lipirea brută și a intrat în acest mod.

    • În caz contrar, rezultatul ar trebui să fie b"ra", dispozitivul nu acceptă lipirea brută, iar șirul b"w REPL; CTRL-B to exit\r\n>" ar trebui citit și ignorat.

  4. Dacă dispozitivul este în modul brut-lipire, atunci continuați, altfel reveniți la modul brut standard.

  5. Citiți 2 octeți, aceasta este creșterea dimensiunii ferestrei de control al fluxului (în octeți), stocată ca un întreg pe 16 biți fără semn, little endian. Valoarea inițială pentru variabila dimensiune-rămasă-fereastră ar trebui setată la acest număr.

  6. Scrieți codul către dispozitiv:

    • Atât timp cât există octeți de trimis, scrieți până la valoarea dimensiunii-rămase-fereastră de octeți și reduceți dimensiunea-rămasă-fereastră cu numărul de octeți scriși.

    • Dacă dimensiunea-rămasă-fereastră este 0 sau dacă există un octet în așteptare pentru citire, citiți 1 octet. Dacă acest octet este b"\x01" atunci măriți dimensiunea-rămasă-fereastră cu valoarea creșterii dimensiunii ferestrei de la pasul 5. Dacă acest octet este b"\x04" atunci dispozitivul dorește să încheie recepția datelor, iar b"\x04" ar trebui scris către dispozitiv și niciun alt cod nu trebuie trimis după aceea. (Notă: dacă există un octet în așteptare pentru a fi citit de la dispozitiv, atunci nu trebuie citit și tratat imediat; dispozitivul va continua să consume octeții primiți atât timp cât dimensiunea-rămasă-fereastră este mai mare decât 0.)

  7. Când tot codul a fost scris către dispozitiv, scrieți b"\x04" pentru a indica sfârșitul datelor.

  8. Citiți de la dispozitiv până când se primește b"\x04". În acest punct, dispozitivul a primit și a compilat tot codul care a fost trimis și îl execută.

  9. Dispozitivul afișează toate caracterele produse de codul în execuție. Când (dacă) codul se termină, va fi afișat b"\x04", urmat de orice excepție care nu a fost prinsă, urmat din nou de b"\x04". Apoi revine la REPL-ul brut standard și afișează b">".

De exemplu, începând la o linie nouă la REPL-ul normal (prietenos), dacă scrieți:

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

Atunci dispozitivul va răspunde cu ceva de genul:

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

Defalcat în timp, acest lucru arată astfel:

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

În acest caz, creșterea dimensiunii ferestrei de control al fluxului este 128 și există date echivalente cu două ferestre disponibile imediat la început, una din valoarea inițială a creșterii dimensiunii ferestrei și una din valoarea explicită b"\x01" care este trimisă. Astfel, aceasta înseamnă că pot fi scriși până la 256 de octeți la început, înainte de a aștepta sau a verifica alte caractere de control al fluxului primite.

Instrumentul Control la distanță MicroPython: mpremote folosește REPL-ul brut, inclusiv modul brut-lipire, pentru a executa cod Python pe camerele OpenMV Cam.