class I2C – פרוטוקול טורי דו-חוטי

I2C הוא פרוטוקול דו-חוטי לתקשורת בין התקנים. ברמה הפיזית הוא מורכב משני קווים, SCL (שעון) ו-SDA (נתונים). ה-OpenMV Cam אינה מספקת נגדי משיכה (pull-up) על הלוח לאף אחד מהקווים – נדרשים נגדי משיכה חיצוניים על שני הקווים SCL ו-SDA כדי שהאפיק יתפקד.

אובייקטי I2C מחוברים לאפיק ספציפי וניתן לאתחל אותם בזמן הבנייה או מאוחר יותר באמצעות init().

דוגמה:

from pyb import I2C

i2c = I2C(2)                              # create on bus 2 (uninitialised)
i2c = I2C(2, I2C.CONTROLLER)              # create and init as a controller
i2c.init(I2C.CONTROLLER, baudrate=20000)  # init as a controller
i2c.init(I2C.PERIPHERAL, addr=0x42)       # init as a peripheral with the given address
i2c.deinit()                              # turn off the peripheral

הדפסת אובייקט ה-I2C מציגה את תצורתו.

המתודות הבסיסיות הן send() ו-recv()

i2c.send("abc")      # send 3 bytes
i2c.send(0x42)       # send a single byte, given by the number
data = i2c.recv(3)   # receive 3 bytes

כדי לקבל במקום, צרו תחילה bytearray

data = bytearray(3)  # create a buffer
i2c.recv(data)       # receive 3 bytes, writing them into data

ניתן לציין פסק זמן (timeout, ב-ms):

i2c.send(b"123", timeout=2000)   # timeout after 2 seconds

בקר חייב לציין את כתובת הנמען:

i2c.init(I2C.CONTROLLER)
i2c.send("123", 0x42)        # send 3 bytes to peripheral with address 0x42
i2c.send(b"456", addr=0x42)  # keyword for address

לבקר יש גם את המתודות הבאות:

# Check if peripheral 0x42 is ready.
i2c.is_ready(0x42)

# Scan the bus and return a list of responding addresses.
i2c.scan()

# Read 3 bytes from peripheral 0x42 starting at memaddr 2.
i2c.mem_read(3, 0x42, 2)

# Write 3 bytes to peripheral 0x42 at memaddr 2.
i2c.mem_write("abc", 0x42, 2, timeout=1000)

בנאים

class pyb.I2C(bus: int | str, *args, **kwargs)

בניית אובייקט I2C על ה-bus הנתון (אינדקס התקן היקפי שלם, למשל 2 עבור I2C2). ללא פרמטרים נוספים האובייקט נוצר אך אינו מאותחל (הוא שומר על הגדרות האפיק הקודמות, אם קיימות); אם ניתנים ארגומנטים נוספים האפיק מאותחל. ראו init() לפרמטרים הזמינים.

I2C(2) מחווט לאותם פיני מחבר בכל OpenMV Cam שחושפת את pyb.I2C (M4 / M7 / H7 / H7 Plus / Pure Thermal):

אות

פין מחבר (header)

הערות

SCL

P4

SDA

P5

I2C(4) זמין בנוסף ב-OpenMV Cam M7, H7, H7 Plus ו-Pure Thermal עם SCL על פין מחבר P7 ו-SDA על פין מחבר P8.

ה-OpenMV Cam N6 אינה חושפת את pyb.I2C; השתמשו ב-machine.I2C במקום.

מתודות

deinit() → None

כיבוי אפיק ה-I2C.

init(mode: int, *, addr: int = 0x12, baudrate: int = 400000, gencall: bool = False, dma: bool = False) → None

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

  • mode חייב להיות או I2C.CONTROLLER או I2C.PERIPHERAL.

  • addr היא הכתובת בת 7 הביט (הגיונית רק עבור התקן היקפי).

  • baudrate הוא קצב שעון ה-SCL (הגיוני רק עבור בקר).

  • gencall הוא האם לתמוך במצב קריאה כללית (general-call).

  • dma הוא האם לאפשר שימוש ב-DMA עבור העברות ה-I2C (שימו לב שהעברות DMA בעלות תזמון מדויק יותר אך כרגע אינן מטפלות כראוי בשגיאות אפיק).

תדר השעון בפועל עשוי להיות נמוך מהתדר המבוקש. הדבר תלוי בחומרת הפלטפורמה. ניתן לקבוע את הקצב בפועל על ידי הדפסת אובייקט ה-I2C.

is_ready(addr: int) → bool

בדיקה אם התקן I2C מגיב לכתובת הנתונה. תקף רק במצב בקר.

mem_read(data: int | bytearray, addr: int, memaddr: int, *, timeout: int = 5000, addr_size: int = 8) → bytes

קריאה מהזיכרון של התקן I2C:

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

  • addr היא כתובת התקן ה-I2C

  • memaddr הוא מיקום הזיכרון בתוך התקן ה-I2C

  • timeout הוא פסק הזמן באלפיות שנייה להמתנה לקריאה

  • addr_size בוחר את רוחב memaddr: 8 או 16 ביט

מחזיר את הנתונים שנקראו. תקף רק במצב בקר.

mem_write(data: int | bytes | bytearray, addr: int, memaddr: int, *, timeout: int = 5000, addr_size: int = 8) → None

כתיבה לזיכרון של התקן I2C:

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

  • addr היא כתובת התקן ה-I2C.

  • memaddr הוא מיקום הזיכרון בתוך התקן ה-I2C.

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

  • addr_size בוחר את רוחב memaddr: 8 או 16 ביט.

תקף רק במצב בקר.

recv(recv: int | bytearray, addr: int = 0x00, *, timeout: int = 5000) → bytes

קבלת נתונים על האפיק:

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

  • addr היא הכתובת לקבל ממנה (נדרש רק במצב בקר)

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

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

send(send: int | bytes | bytearray, addr: int = 0x00, *, timeout: int = 5000) → None

שליחת נתונים על האפיק:

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

  • addr היא הכתובת לשלוח אליה (נדרש רק במצב בקר).

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

scan() → List[int]

סריקת כל כתובות ה-I2C מ-0x01 עד 0x7f והחזרת רשימה של אלו שמגיבות. תקף רק במצב בקר.

קבועים

CONTROLLER: int

מאתחל את האפיק כ-master (בקר) – הוא מניע את SCL ויוזם טרנזקציות.

PERIPHERAL: int

מאתחל את האפיק כ-slave (התקן היקפי) המאזין על ה-addr שנקבע ב-init() ומגיב לטרנזקציות שיוזם בקר על אותו אפיק.