class SPI – פרוטוקול אפיק Serial Peripheral Interface (צד הבקר)#

SPI הוא פרוטוקול טורי סינכרוני המונע על ידי בקר. ברמה הפיזית, אפיק מורכב מ-3 קווים: SCK, MOSI, MISO. התקנים מרובים יכולים לחלוק את אותו האפיק. לכל התקן צריך להיות אות נפרד, רביעי, CS (Chip Select), כדי לבחור התקן מסוים באפיק שאיתו מתבצעת התקשורת. ניהול אות ה-CS צריך להתבצע בקוד המשתמש (באמצעות המחלקה machine.Pin).

קיימים מימושי SPI חומרתיים ותוכנתיים כאחד באמצעות המחלקות SPI ו-SoftSPI. SPI חומרתי משתמש בתמיכת החומרה הבסיסית של המערכת כדי לבצע את הקריאות/כתיבות, והוא בדרך כלל יעיל ומהיר אך עשוי להיות מוגבל לגבי הפינים שניתן להשתמש בהם. SPI תוכנתי ממומש באמצעות bit-banging וניתן להשתמש בו בכל פין אך אינו יעיל באותה מידה. למחלקות אלו יש את אותן המתודות הזמינות, והן נבדלות בעיקר באופן שבו הן נבנות.

דוגמת שימוש:

from machine import SPI, Pin

spi = SPI(0, baudrate=400000)           # Create SPI peripheral 0 at frequency of 400kHz.
                                        # Depending on the use case, extra parameters may be required
                                        # to select the bus characteristics and/or pins to use.
cs = Pin(4, mode=Pin.OUT, value=1)      # Create chip-select on pin 4.

try:
    cs(0)                               # Select peripheral.
    spi.write(b"12345678")              # Write 8 bytes, and don't care about received data.
finally:
    cs(1)                               # Deselect peripheral.

try:
    cs(0)                               # Select peripheral.
    rxdata = spi.read(8, 0x42)          # Read 8 bytes while writing 0x42 for each byte.
finally:
    cs(1)                               # Deselect peripheral.

rxdata = bytearray(8)
try:
    cs(0)                               # Select peripheral.
    spi.readinto(rxdata, 0x42)          # Read 8 bytes inplace while writing 0x42 for each byte.
finally:
    cs(1)                               # Deselect peripheral.

txdata = b"12345678"
rxdata = bytearray(len(txdata))
try:
    cs(0)                               # Select peripheral.
    spi.write_readinto(txdata, rxdata)  # Simultaneously write and read bytes.
finally:
    cs(1)                               # Deselect peripheral.

בנאים#

class machine.SPI(id: int, baudrate: int = 1000000, *, polarity: int = 0, phase: int = 0, bits: int = 8, firstbit: int = MSB, sck: Pin | None = None, mosi: Pin | None = None, miso: Pin | None = None)#

בונה אובייקט SPI על האפיק הנתון, id. ערכי id תלויים בפורט מסוים ובחומרה שלו. הערכים 0, 1 וכו« נמצאים בשימוש נפוץ לבחירת בלוק SPI חומרתי מס« 0, מס« 1 וכו«.

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

מתודות#

init(baudrate: int = 1000000, *, polarity: int = 0, phase: int = 0, bits: int = 8, firstbit: int = SPI.MSB, sck: Pin | None = None, mosi: Pin | None = None, miso: Pin | None = None) → None#

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

baudrate הוא קצב שעון ה-SCK.
polarity יכול להיות 0 או 1, והוא הרמה שבה יושב קו השעון במצב סרק.
phase יכול להיות 0 או 1 כדי לדגום נתונים בקצה השעון הראשון או השני בהתאמה.
bits הוא הרוחב בביטים של כל העברה. רק 8 מובטח להיתמך על ידי כל החומרה.
firstbit יכול להיות SPI.MSB או SPI.LSB.
sck, mosi, miso הם פינים (אובייקטים machine.Pin) שישמשו לאותות האפיק. עבור רוב בלוקי ה-SPI החומרתיים (כפי שנבחרו על ידי הפרמטר id לבנאי), הפינים קבועים ואינם ניתנים לשינוי. במקרים מסוימים, בלוקי חומרה מאפשרים 2-3 קבוצות פינים חלופיות עבור בלוק SPI חומרתי. הקצאות פינים שרירותיות אפשריות רק עבור מנהל התקן SPI מסוג bitbanging (id = -1).

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

deinit() → None#: מכבה את אפיק ה-SPI.

read(nbytes: int, write: int = 0x00) → bytes#: קורא מספר בתים שצוין על ידי nbytes תוך כדי כתיבה מתמשכת של הבית הבודד הנתון על ידי write. מחזיר אובייקט bytes עם הנתונים שנקראו.

readinto(buf: bytearray, write: int = 0x00) → None#: קורא לתוך החוצץ שצוין על ידי buf תוך כדי כתיבה מתמשכת של הבית הבודד הנתון על ידי write. מחזיר None.

write(buf: bytes) → None#: כותב את הבתים הכלולים ב-buf. מחזיר None.

write_readinto(write_buf: bytes, read_buf: bytearray) → None#: כותב את הבתים מ-write_buf תוך כדי קריאה לתוך read_buf. החוצצים יכולים להיות זהים או שונים, אך לשני החוצצים חייב להיות אותו אורך. מחזיר None.

קבועים#

MSB: int#: העבר אל firstbit כדי לשדר/לקבל תחילה את הביט המשמעותי ביותר (הסדר הנפוץ ביותר).

LSB: int#: העבר אל firstbit כדי לשדר/לקבל תחילה את הביט הפחות משמעותי.

class SoftSPI – אפיק SPI בהדמיית תוכנה#

המחלקה SoftSPI מממשת SPI באמצעות bit-banging של פיני GPIO שרירותיים. היא חושפת את אותו מערך מתודות כמו SPI, כך שקוד קיים שמכוון ל-SPI חומרתי יכול לעבור לתוכנה רק בשינוי הבנאי. השתמש בה כאשר הפינים שאתה צריך אינם מחווטים לבלוק SPI חומרתי, כאשר אתה צריך יותר מהאפיקים החומרתיים הזמינים, או כאשר התקן היקפי דורש פאזת שעון לא סטנדרטית שהחומרה אינה יכולה להפיק.

בנאים#

class machine.SoftSPI(baudrate: int = 500000, *, polarity: int = 0, phase: int = 0, bits: int = 8, firstbit: int = MSB, sck: Pin | None = None, mosi: Pin | None = None, miso: Pin | None = None)#

בונה אובייקט SPI תוכנתי. יש לספק את sck, mosi ו-miso – אין בחירת פינים מובלעת. ראה SPI.init() לקבלת משמעות שאר הפרמטרים. ברירת המחדל של baudrate נמוכה יותר מאשר עבור SPI חומרתי משום שללולאת ה-bit-bang יש תקורה גבוהה יותר.

מתודות#

init(baudrate: int = 500000, *, polarity: int = 0, phase: int = 0, bits: int = 8, firstbit: int = SoftSPI.MSB, sck: Pin | None = None, mosi: Pin | None = None, miso: Pin | None = None) → None#: מאתחל מחדש את אפיק ה-SPI התוכנתי עם הפרמטרים הנתונים. רק ארגומנטים שסופקו מעודכנים; השאר שומרים על ערכיהם הקודמים. ראה SPI.init() לקבלת משמעות כל ארגומנט.

deinit() → None#: משחרר את פיני ה-GPIO שתפס מנהל ההתקן של bit-bang ומפסיק לתפעל את האפיק.

read(nbytes: int, write: int = 0x00) → bytes#: קורא nbytes בתים תוך כדי כתיבה מתמשכת של הבית הבודד write. מחזיר אובייקט bytes המכיל את הנתונים שהתקבלו.

readinto(buf: bytearray, write: int = 0x00) → None#: קורא לתוך buf תוך כדי כתיבה מתמשכת של הבית הבודד write. מחזיר None.

write(buf: bytes) → None#: כותב את buf אל האפיק. בתים שהתקבלו מושמטים.

write_readinto(write_buf: bytes, read_buf: bytearray) → None#: כותב בו-זמנית את write_buf וקורא לתוך read_buf. שני החוצצים חייבים להיות באותו אורך; הם רשאים לחפוף (alias).

קבועים#

MSB: int#: העבר אל firstbit כדי לשדר/לקבל תחילה את הביט המשמעותי ביותר.

LSB: int#: העבר אל firstbit כדי לשדר/לקבל תחילה את הביט הפחות משמעותי.