מחלקה USB_VCP – פורט תקשורת וירטואלי של USB

המחלקה USB_VCP מאפשרת יצירת אובייקט דמוי-stream המייצג את פורט התקשורת הווירטואלי של USB. ניתן להשתמש בה כדי לקרוא ולכתוב נתונים דרך USB אל המארח המחובר.

בנאים

class pyb.USB_VCP(id: int = 0)

יוצר אובייקט USB_VCP חדש. הארגומנט id בוחר באיזה פורט USB VCP להשתמש כאשר נחשף יותר מאחד.

מתודות

init(*, flow: int = -1) → None

מגדיר את פורט ה-USB VCP. אם הארגומנט flow אינו -1 הוא מגדיר את בקרת הזרימה, OR ביטווייז של USB_VCP.RTS ו-USB_VCP.CTS. RTS שולט בהתנהגות הקריאה; CTS שולט בהתנהגות הכתיבה.

setinterrupt(chr: int) → None

מגדיר את התו שמפסיק קוד Python רץ. זה מוגדר ל-3 (CTRL-C) כברירת מחדל, וכאשר תו CTRL-C מתקבל דרך פורט ה-USB VCP, נזרקת חריגת KeyboardInterrupt.

הגדירו ל-1- כדי לבטל את תכונת הפסיקה הזו. הדבר שימושי כאשר רוצים לשלוח בייטים גולמיים דרך פורט ה-USB VCP.

isconnected() → bool

מחזיר True אם ה-USB מחובר כהתקן טורי, אחרת False.

debug_mode_enabled() → bool

מחזיר True אם OpenMV IDE מחובר ל-OpenMV Cam.

any() → bool

מחזיר True אם יש תווים כלשהם הממתינים, אחרת False.

close() → None

מתודה זו אינה עושה דבר. היא קיימת כדי שאובייקט ה-USB_VCP יוכל להתנהג כקובץ.

read(nbytes: int | None = None) → bytes | None

קורא לכל היותר nbytes מההתקן הטורי ומחזיר אותם כאובייקט bytes. אם nbytes אינו מצוין אזי המתודה קוראת את כל הבייטים הזמינים מההתקן הטורי. ה-stream של USB_VCP פועל באופן מובנה במצב לא-חוסם, ולכן אם אין נתונים ממתינים זמינים, מתודה זו תחזור מיד עם ערך None.

readinto(buf: bytearray, maxlen: int | None = None) → int | None

קורא בייטים מההתקן הטורי ומאחסן אותם ב-buf, שצריך להיות אובייקט דמוי-חוצץ. נקראים לכל היותר len(buf) בייטים. אם maxlen ניתן אזי נקראים לכל היותר min(maxlen, len(buf)) בייטים.

מחזיר את מספר הבייטים שנקראו ואוחסנו ב-buf או None אם אין נתונים ממתינים זמינים.

readline() → bytes | None

קורא שורה שלמה מההתקן הטורי.

מחזיר אובייקט bytes המכיל את הנתונים, כולל תו השורה החדשה הסופי, או None אם אין נתונים ממתינים זמינים.

readlines() → List[bytes]

קורא כמה שיותר נתונים מההתקן הטורי, ומפצל אותם לשורות.

מחזיר רשימה של אובייקטי bytes, כשכל אובייקט הוא אחת מהשורות. כל שורה תכלול את תו השורה החדשה.

write(buf: bytes | bytearray | str) → int

כותב את הבייטים מ-buf אל ההתקן הטורי.

מחזיר את מספר הבייטים שנכתבו.

recv(data: int | bytearray, *, timeout: int = 5000) → bytes | int

קולט נתונים מהאפיק:

• data יכול להיות מספר שלם, שהוא מספר הבייטים לקליטה, או חוצץ ניתן לשינוי, שיתמלא בבייטים שהתקבלו.

• timeout הוא הזמן הקצוב באלפיות שנייה להמתנה לקליטה.

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

send(data: int | bytes | bytearray, *, timeout: int = 5000) → int

שולח נתונים דרך ה-USB VCP:

• data הם הנתונים לשליחה (מספר שלם לשליחה, או אובייקט חוצץ).

• timeout הוא הזמן הקצוב באלפיות שנייה להמתנה לשליחה.

ערך מוחזר: מספר הבייטים שנשלחו.

irq(handler: Callable[[USB_VCP], None] | None = None, trigger: int = IRQ_RX, hard: bool = False) → None

רושם את handler כך שייקרא בכל פעם שמתרחש אירוע שצוין על ידי trigger. פונקציית ה-handler חייבת לקבל ארגומנט אחד בדיוק, שיהיה אובייקט ה-USB VCP. העבירו None כדי לבטל את פונקציית ה-callback.

ערכים תקפים עבור trigger הם:

• USB_VCP.IRQ_RX: נתונים חדשים זמינים לקריאה מאובייקט ה-USB VCP.

קבועים

RTS: int

דגל בקרת זרימה עבור init(). אפשור RTS גורם להתקן לרסן את שידור המארח כאשר חוצץ הקריאה מלא.

CTS: int

דגל בקרת זרימה עבור init(). אפשור CTS גורם להתקן לכבד את בקרת הזרימה של המארח במהלך כתיבות (חוסם עד שהמארח מוכן לקלוט). ניתן לבצע עליו OR עם RTS.

IRQ_RX: int

טריגר של irq(): נורה כאשר נתונים חדשים זמינים לקריאה מאובייקט ה-USB VCP.