מצב המפרש האינטראקטיבי של MicroPython (המכונה גם REPL)

סעיף זה מכסה כמה מאפיינים של מצב המפרש האינטראקטיבי של MicroPython. מונח נפוץ עבורו הוא REPL (read-eval-print-loop), שבו נשתמש כדי להתייחס לשורת הפקודה האינטראקטיבית הזו.

הערה

מצלמות OpenMV Cam חושפות את ה-REPL הזה דרך יציאת ה-USB הטורית (CDC) שלהן. הדבר רלוונטי רק כאשר אתה מתחבר ישירות למצלמה באמצעות אמולטור מסוף טורי (או כלי כגון שליטה מרחוק ב-MicroPython: mpremote). OpenMV IDE אינו משתמש ב-REPL — הוא מתקשר עם המצלמה דרך פרוטוקול ניפוי באגים נפרד כדי להריץ סקריפטים, להעביר קבצים ולהזרים את חוצץ הפריימים (frame buffer). כל מה שמתואר בדף זה חל על הפעלות מסוף ישירות בלבד.

הזחה אוטומטית

כשמקלידים פקודות Python המסתיימות בנקודתיים (לדוגמה if, for, while), שורת הפקודה תשתנה לשלוש נקודות (…) והסמן יוזח ב-4 רווחים. כשתלחץ Enter, השורה הבאה תמשיך באותה רמת הזחה עבור פקודות רגילות, או ברמת הזחה נוספת היכן שמתאים. אם תלחץ על מקש ה-Backspace, הוא יבטל רמת הזחה אחת.

אם הסמן שלך נמצא בחזרה בתחילת השורה, לחיצה על RETURN תריץ את הקוד שהזנת. הדוגמה הבאה מראה מה תראה לאחר הזנת פקודת for (הקו התחתון מציין היכן הסמן מסתיים):

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

אם לאחר מכן תזין פקודת if, תינתן רמת הזחה נוספת:

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

כעת הזן break ולאחריו RETURN ולחץ BACKSPACE:

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

לבסוף הקלד print(i), לחץ RETURN, לחץ BACKSPACE ולחץ RETURN שוב:

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

הזחה אוטומטית לא תוחל אם שתי השורות הקודמות היו כולן רווחים. משמעות הדבר היא שאתה יכול לסיים הזנת פקודה מורכבת בלחיצה על RETURN פעמיים, ולחיצה שלישית תסיים ותריץ.

השלמה אוטומטית

תוך כדי הקלדת פקודה ב-REPL, אם השורה שהוקלדה עד כה מתאימה לתחילת שם של משהו, אזי לחיצה על TAB תציג את הדברים האפשריים שניתן להזין. לדוגמה, ראשית ייבא את מודול machine על ידי הזנת import machine ולחיצה על RETURN. לאחר מכן הקלד m ולחץ TAB, והוא אמור להתרחב ל-machine. הזן נקודה . ולחץ TAB שוב. אמורה להופיע תוצאה דומה ל:

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

המילה תורחב ככל האפשר עד שיתקיימו אפשרויות מרובות. לדוגמה, הקלד machine.Pin.PULL ולחץ TAB, והוא יתרחב ל-machine.Pin.PULL_. לחיצה על TAB בפעם השנייה תציג את ההרחבות האפשריות:

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

הפסקת תוכנית פועלת

אתה יכול להפסיק תוכנית פועלת בלחיצה על Ctrl-C. פעולה זו תעורר KeyboardInterrupt אשר תחזיר אותך ל-REPL, בתנאי שהתוכנית שלך אינה מיירטת את חריגת KeyboardInterrupt.

לדוגמה:

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

מצב הדבקה

אם תרצה להדביק קוד כלשהו לחלון המסוף שלך, תכונת ההזחה האוטומטית תקלקל את הדברים. לדוגמה, אם היה לך קוד ה-Python הבא:

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

ותנסה להדביק אותו ל-REPL הרגיל, אזי תראה משהו כזה:

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

אם תלחץ Ctrl-E, אזי תיכנס למצב הדבקה, אשר למעשה מכבה את תכונת ההזחה האוטומטית, ומשנה את שורת הפקודה מ->>> ל-===. לדוגמה:

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

מצב הדבקה מאפשר הדבקת שורות ריקות. הטקסט המודבק עובר קומפילציה כאילו היה קובץ. לחיצה על Ctrl-D יוצאת ממצב הדבקה ומפעילה את הקומפילציה.

איפוס רך

איפוס רך יאפס את מפרש Python, אך ינסה שלא לאפס את השיטה שבה אתה מחובר ל-OpenMV Cam (USB).

אתה יכול לבצע איפוס רך מתוך ה-REPL בלחיצה על Ctrl-D, או מתוך קוד ה-Python שלך על ידי הרצת:

machine.soft_reset()

לדוגמה, אם תאפס את ה-OpenMV Cam שלך ותריץ פקודת dir(), תראה משהו כזה:

>>> dir()
['__name__']

כעת צור כמה משתנים וחזור על פקודת dir():

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

כעת אם תזין Ctrl-D, ותחזור על פקודת dir(), תראה שהמשתנים שלך אינם קיימים עוד:

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

למידע נוסף על סוגי איפוס ותהליך האתחול, ראה רצף איפוס ואתחול.

המשתנה המיוחד _ (קו תחתון)

כשאתה משתמש ב-REPL, אתה עשוי לבצע חישובים ולראות את התוצאות. MicroPython שומר את תוצאת הפקודה הקודמת במשתנה _ (קו תחתון). כך שאתה יכול להשתמש בקו התחתון כדי לשמור את התוצאה במשתנה. לדוגמה:

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

מצב גולמי ומצב הדבקה גולמי

מצב גולמי (הנקרא גם raw REPL) אינו דבר שאדם ישתמש בו בדרך כלל. הוא מיועד לשימוש תוכנתי ומתנהג למעשה כמו מצב הדבקה כשהד מכובה, ועם בקרת זרימה אופציונלית.

נכנסים למצב גולמי באמצעות Ctrl-A. לאחר מכן אתה שולח את קוד ה-Python שלך, ולאחריו Ctrl-D. ה-Ctrl-D יאושר באמצעות »OK«, ולאחר מכן קוד ה-Python יעבור קומפילציה ויורץ. כל פלט (או שגיאות) יישלח בחזרה. הזנת Ctrl-B תצא ממצב גולמי ותחזיר את ה-REPL הרגיל (המכונה גם ידידותי).

מצב הדבקה גולמי הוא מצב נוסף בתוך ה-raw REPL הכולל בקרת זרימה, ואשר עובר קומפילציה לקוד תוך כדי קבלתו. הדבר הופך אותו לעמיד יותר עבור העברת קוד במהירות גבוהה אל ההתקן, וגם משתמש בפחות RAM בעת הקבלה משום שאינו צריך לאחסן עותק מילולי של הקוד לפני הקומפילציה (בניגוד למצב הגולמי הסטנדרטי).

מצב הדבקה גולמי משתמש בפרוטוקול הבא:

1. היכנס ל-raw REPL כרגיל באמצעות ctrl-A.

2. כתוב 3 בתים: b"\x05A\x01" (כלומר ctrl-E ואז ”A“ ואז ctrl-A).

3. קרא 2 בתים כדי לקבוע אם ההתקן נכנס למצב הדבקה גולמי:

   • אם התוצאה היא b"R\x00" אזי ההתקן מבין את הפקודה אך אינו תומך בהדבקה גולמית.

   • אם התוצאה היא b"R\x01" אזי ההתקן אכן תומך בהדבקה גולמית ונכנס למצב זה.

   • אחרת התוצאה אמורה להיות b"ra" וההתקן אינו תומך בהדבקה גולמית, ויש לקרוא ולהשליך את המחרוזת b"w REPL; CTRL-B to exit\r\n>".

4. אם ההתקן נמצא במצב הדבקה גולמי אזי המשך, אחרת חזור למצב גולמי סטנדרטי.

5. קרא 2 בתים, זהו ערך גידול חלון בקרת הזרימה (בבתים) המאוחסן כמספר שלם בגודל 16 ביט ללא סימן בסדר little endian. הערך ההתחלתי של משתנה גודל-החלון-הנותר אמור להיקבע למספר זה.

6. כתוב את הקוד אל ההתקן:

   • כל עוד יש בתים לשליחה, כתוב עד כמות הבתים בגודל-החלון-הנותר, והפחת את גודל-החלון-הנותר במספר הבתים שנכתבו.

   • אם גודל-החלון-הנותר הוא 0, או שיש בית הממתין לקריאה, קרא בית אחד. אם בית זה הוא b"\x01" אזי הגדל את גודל-החלון-הנותר בערך גידול-החלון משלב 5. אם בית זה הוא b"\x04" אזי ההתקן רוצה לסיים את קבלת הנתונים, ויש לכתוב b"\x04" אל ההתקן ולא לשלוח עוד קוד לאחר מכן. (הערה: אם יש בית הממתין לקריאה מההתקן אזי אין צורך לקרוא אותו ולפעול לפיו מיד, ההתקן ימשיך לצרוך בתים נכנסים כל עוד גודל-החלון-הנותר גדול מ-0.)

7. כאשר כל הקוד נכתב אל ההתקן, כתוב b"\x04" כדי לציין סוף-נתונים.

8. קרא מההתקן עד שמתקבל b"\x04". בנקודה זו ההתקן קיבל וקימפל את כל הקוד שנשלח ומריץ אותו.

9. ההתקן מוציא כל תו שנוצר על ידי הקוד הפועל. כאשר (אם) הקוד מסתיים, b"\x04" יוצא, ולאחריו כל חריגה שלא נתפסה, ולאחר מכן שוב b"\x04". לאחר מכן הוא חוזר ל-raw REPL הסטנדרטי ומוציא b">".

לדוגמה, החל משורה חדשה ב-REPL הרגיל (הידידותי), אם תכתוב:

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

אז ההתקן יגיב במשהו כמו:

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

מפורק לאורך זמן זה נראה כך:

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

במקרה זה ערך גידול חלון בקרת הזרימה הוא 128 ויש שני חלונות של נתונים זמינים מיד בהתחלה, אחד מערך גידול-החלון ההתחלתי ואחד מערך ה-b"\x01" המפורש שנשלח. כך שמשמעות הדבר היא שניתן לכתוב עד 256 בתים בהתחלה לפני המתנה או בדיקה לתווי בקרת זרימה נכנסים נוספים.

הכלי שליטה מרחוק ב-MicroPython: mpremote משתמש ב-raw REPL, כולל מצב הדבקה גולמי, כדי להריץ קוד Python על מצלמות OpenMV Cam.