class UART – אפיק תקשורת טורית דו-כיוונית¶

UART מממש את פרוטוקול התקשורת הטורית הדו-כיוונית הסטנדרטי UART/USART. ברמה הפיזית הוא מורכב מ-2 קווים: RX ו-TX. יחידת התקשורת היא תו (אין לבלבל עם תו במחרוזת) שיכול להיות ברוחב 8 או 9 ביטים.

ניתן ליצור ולאתחל אובייקטי UART באמצעות:

from machine import UART

uart = UART(3, 9600)                         # init with given baudrate
uart.init(9600, bits=8, parity=None, stop=1) # init with given parameters

Bits יכול להיות 7, 8 או 9. Stop יכול להיות 1 או 2. עם parity=None, נתמכים רק 8 ו-9 ביטים. כאשר parity מאופשר, נתמכים רק 7 ו-8 ביטים.

אובייקט UART מתנהג כמו אובייקט stream, וקריאה וכתיבה נעשות באמצעות מתודות ה-stream הסטנדרטיות:

uart.read(10)       # read 10 characters, returns a bytes object
uart.read()         # read all available characters
uart.readline()     # read a line
uart.readinto(buf)  # read and store into the given buffer
uart.write('abc')   # write the 3 characters

בנאים¶

בניית אובייקט UART בעל ה-id הנתון.

מתודות¶

אתחול אפיק ה-UART עם הפרמטרים הנתונים:

baudrate הוא קצב השעון.

bits הוא מספר הביטים לכל תו, 7, 8 או 9.

parity הוא הזוגיות, None, 0 (זוגי) או 1 (אי-זוגי).

stop הוא מספר ביטי העצירה, 1 או 2.

פרמטרים נוספים, מסוג מילת מפתח בלבד, שעשויים להיות נתמכים על ידי פורט:

tx מציין את פין ה-TX לשימוש.

rx מציין את פין ה-RX לשימוש.

rts מציין את פין ה-RTS (פלט) שישמש לבקרת זרימה חומרתית בקליטה.

cts מציין את פין ה-CTS (קלט) שישמש לבקרת זרימה חומרתית בשידור.

txbuf מציין את אורך חוצץ ה-TX בתווים.

rxbuf מציין את אורך חוצץ ה-RX בתווים.

timeout מציין את משך ההמתנה לתו הראשון (במילישניות).

timeout_char מציין את משך ההמתנה בין תווים (במילישניות).

invert מציין אילו קווים להפוך.

0 לא יהפוך קווים (מצב הסרק של שני הקווים הוא לוגי גבוה).

UART.INV_TX יהפוך את קו ה-TX (מצב הסרק של קו ה-TX הוא כעת לוגי נמוך).

UART.INV_RX יהפוך את קו ה-RX (מצב הסרק של קו ה-RX הוא כעת לוגי נמוך).

UART.INV_TX | UART.INV_RX יהפוך את שני הקווים (מצב הסרק לוגי נמוך).

flow מציין אילו אותות בקרת זרימה חומרתית להשתמש. הערך הוא מסכת ביטים.

0 יתעלם מאותות בקרת זרימה חומרתית.

UART.RTS יאפשר בקרת זרימה בקליטה באמצעות פין הפלט RTS כדי לאותת אם ל-FIFO של הקליטה יש מספיק מקום לקבל נתונים נוספים.

UART.CTS יאפשר בקרת זרימה בשידור על ידי השהיית השידור כאשר פין הקלט CTS מאותת שמקום החוצץ של המקלט אוזל.

UART.RTS | UART.CTS יאפשר את שניהם, לבקרת זרימה חומרתית מלאה.

הערה

ניתן לקרוא ל-init() מספר פעמים על אותו אובייקט כדי להגדיר מחדש את ה-UART תוך כדי תנועה. זה מאפשר להשתמש בהתקן UART היקפי יחיד כדי לשרת התקנים שונים המחוברים לפיני GPIO שונים. רק התקן אחד יכול להיות משוֹרת בכל פעם במקרה כזה. כמו כן, אין לקרוא ל-deinit() שכן זה ימנע קריאה חוזרת ל-init().

deinit() → None¶: כיבוי אפיק ה-UART.

הערה

לא תוכל לקרוא ל-init() על האובייקט לאחר deinit(). במקרה כזה יש ליצור מופע חדש.

any() → int¶

מחזיר מספר שלם הסופר את מספר התווים שניתן לקרוא ללא חסימה. הוא יחזיר 0 אם אין תווים זמינים ומספר חיובי אם יש תווים. המתודה עשויה להחזיר 1 גם אם יש יותר מתו אחד הזמין לקריאה.

לשאילתה מתוחכמת יותר של תווים זמינים השתמש ב-select.poll:

poll = select.poll()
poll.register(uart, select.POLLIN)
poll.poll(timeout)

read(nbytes: int | None = None, /) → bytes | None¶

קריאת תווים. אם nbytes מצוין, יקראו לכל היותר מספר זה של בייטים, אחרת יקראו כמה שיותר נתונים. ייתכן שהקריאה תחזור מוקדם יותר אם הושג timeout. ה-timeout ניתן להגדרה בבנאי.

ערך מוחזר: אובייקט bytes המכיל את הבייטים שנקראו. מחזיר None בעת timeout.

readinto(buf: bytearray, nbytes: int | None = None, /) → int | None¶

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

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

readline() → bytes | None¶

קריאת שורה, המסתיימת בתו שורה חדשה. ייתכן שהקריאה תחזור מוקדם יותר אם הושג timeout. ה-timeout ניתן להגדרה בבנאי.

ערך מוחזר: השורה שנקראה או None בעת timeout.

write(buf: bytes) → int | None¶

כתיבת חוצץ הבייטים אל האפיק.

ערך מוחזר: מספר הבייטים שנכתבו או None בעת timeout.

sendbreak() → None¶: שליחת תנאי break על האפיק – הנמכת TV לרמה נמוכה למשך זמן ארוך יותר מזמן תו אחד. זמין ב-STM32 וב-mimxrt; אינו חשוף ב-alif.

readchar() → int¶: קריאת תו בודד מה-UART והחזרתו כמספר שלם (או -1 בעת timeout). תקורה נמוכה יותר מ-read(1) מכיוון שלא מוקצה אובייקט bytes. STM32 בלבד.

writechar(char: int) → None¶: כתיבת התו הבודד char (מספר שלם בטווח 0 – 255) אל ה-UART. תקורה נמוכה יותר מ-write() עבור שליחת בייט בודד. STM32 בלבד.

flush() → None¶: חסימה עד שכל בייט הנמצא כעת בחוצץ השידור יוצא בשעון על TX. מעלה OSError בעת timeout; ה-timeout נגזר מגודל חוצץ ה-TX ומקצב הבָּאוּד (baud rate) המוגדר, כך שאלא אם כן בקרת זרימה מאופשרת והמקלט נתקע, הקריאה חוזרת הרבה לפני ה-timeout.

txdone() → bool¶: מחזיר True כאשר אין שידור בתהליך (חוצץ ה-TX ריק ואוגר ההזזה התרוקן), False אחרת. שימושי כחלופה לא-חוסמת ל-flush().

irq(handler: Callable[[UART], None] | None = None, trigger: int = 0, hard: bool = False) → None¶

התקנת פונקציית callback שתופעל באירועי UART.

handler הוא הפונקציה שתופעל. היא מקבלת את מופע ה-UART כארגומנט היחיד שלה. העבר None כדי להסיר handler שהותקן קודם לכן.

trigger הוא מסכת ביטים של קבוע IRQ_* אחד או יותר (ראה Constants למטה) הבוחרת אילו אירועים יפעילו את ה-callback.

hard=True רושם handler של פסיקה חומרתית (השהיה נמוכה יותר, אך ה-handler אינו רשאי להקצות). ברירת המחדל היא callback מתוזמן.

מחזיר אובייקט irq.

לא כל מקור IRQ זמין בכל פורט – ראה את קבועי IRQ_* הבודדים לזמינות לפי פורט.

קבועים¶

RTS: int¶: העבר ל-flow כדי לאפשר בקרת זרימה חומרתית RTS בצד הקליטה. שלב עם CTS באמצעות OR כדי לאפשר את שניהם.

CTS: int¶: העבר ל-flow כדי לאפשר בקרת זרימה חומרתית CTS בצד השידור.

IRQ_RXIDLE: int¶: דגל הפעלה של irq(): מופעל פעם אחת לאחר שתו אחד או יותר התקבל ואז קו ה-RX עובר למצב סרק. זמין בכל פורטי OpenMV.

IRQ_RX: int¶: דגל הפעלה של irq(): מופעל לאחר כל תו שמתקבל. זמין ב-STM32 וב-alif.

IRQ_TXIDLE: int¶: דגל הפעלה של irq(): מופעל כאשר התו האחרון של שידור יצא בשעון. זמין ב-mimxrt וב-alif.

IRQ_BREAK: int¶: דגל הפעלה של irq(): מופעל כאשר מזוהה תנאי break על RX. אינו זמין באף פורט של OpenMV.