class SDCard – מנהל התקן לכרטיס SD / MMC

המחלקה SDCard מתפעלת את חריץ כרטיס ה-SD / MMC במצלמות OpenMV שיש בהן כזה. מנהל ההתקן מממש את הממשק vfs.AbstractBlockDev כך שניתן להעבירו ישירות אל vfs.mount()

import machine
import vfs

sd = machine.SDCard()
vfs.mount(sd, "/sd")

הערה

הקושחה של OpenMV מבצעת עיגון אוטומטי של כרטיס ה-SD באתחול, ולכן רוב הסקריפטים אינם בונים ישירות אובייקט SDCard – הם פשוט קוראים וכותבים דרך הנתיב המעוגן אוטומטית. בנה אובייקט ידנית רק כאשר דרושה לך נקודת עיגון שאינה ברירת המחדל, או גישה גולמית ברמת הבלוק דרך readblocks() / writeblocks() / ioctl().

במצלמות OpenMV Cam M7 / H7 / H7 Plus / Pure Thermal / N6 החריץ מתופעל על ידי בקר ה-SDMMC המובנה בשבב ה-STM32 במצב SD של 4 ביט. במצלמת OpenMV Cam RT1062 החריץ מתופעל על ידי בקר ה-USDHC של ה-i.MX RT, גם כן במצב SD של 4 ביט. אין צורך בארגומנטים של ריבוב פינים (pin-mux) באף לוח OpenMV נוכחי – מנהל ההתקן מכיר את החיווט של הלוח.

אינו נחשף ב-OpenMV Cam AE3 (פורט alif).

בנאים

class machine.SDCard(id: int = 1) → SDCard

מחזיר את המופע היחיד (singleton) של SDCard עבור חריץ ה-SD המזוהה על ידי id. id מתקבל לצורך תאימות בין פורטים, אך הפורטים הנתמכים על ידי OpenMV חושפים חריץ אחד בלבד; העבר 1 או השמט אותו.

ב-STM32 הבנאי אינו מקבל ארגומנטים כלל; ב-mimxrt הארגומנט id מתקבל אך רק 1 תקף.

מתודות

present() → bool

מחזיר True אם כרטיס מזוהה כעת בחריץ, ו-False אחרת.

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

info() → tuple[int, int, int]

מחזיר שלשה (3-tuple) המתארת את הכרטיס המוכנס כעת:

  • [0] num_blocks – הקיבולת הכוללת בבלוקים של 512 בתים. הכפל ב-512 כדי לקבל את הקיבולת הגולמית בבתים.

  • [1] block_size – תמיד 512 עבור כרטיסי SD. כלול כדי שהקוראים יוכלו לבצע num_blocks * block_size באופן נייד.

  • [2] card_type – סוג הכרטיס המדווח על ידי אפיק ה-SD במהלך לחיצת היד של האתחול CMD8 / OCR. ערכים אופייניים הם 0 (SDSC – קיבולת סטנדרטית), 0x40 (SDHC / SDXC – קיבולת גבוהה / מורחבת) ו-0x80 (MMC).

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

power(state: bool, /) → None

מדליק או מכבה את פס המתח של חריץ הכרטיס. הקושחה של STM32 חושפת את המתודה, אך אף OpenMV Cam נוכחי אינו שולט בהזנת המתח של ה-SD, ולכן הקריאה היא למעשה ללא-פעולה (no-op). נשמר לצורך תאימות עם קוד שנכתב במקור עבור לוחות הייחוס של STM32 ב-MicroPython המקורי. פורט STM32 בלבד.

read(block_num: int, /) → bytes

קורא בלוק בודד של 512 בתים מהכרטיס ומחזיר אותו כאובייקט bytes חדש שהוקצה.

זוהי קריאת הבלוק הבודד המורשת שסופקה על ידי פורט STM32. קוד חדש צריך להשתמש ב-readblocks() במקום – מתודה זו פועלת בכל פורט של OpenMV, יכולה לקרוא כל מספר של בלוקים רציפים בהעברה אחת, ונמנעת מההקצאה שבכל קריאה על ידי כתיבה לתוך חוצץ (buffer) שסופק על ידי הקורא. פורט STM32 בלבד.

write(block_num: int, data: bytes, /) → None

כותב בלוק בודד של 512 בתים אל הכרטיס. data חייב להיות באורך של בדיוק 512 בתים.

זוהי כתיבת הבלוק הבודד המורשת שסופקה על ידי פורט STM32; קוד חדש צריך להשתמש ב-writeblocks() במקום, אשר פועלת בכל פורט של OpenMV ויכולה לכתוב כל מספר של בלוקים רציפים בכל קריאה. פורט STM32 בלבד.

readblocks(block_num: int, buf: bytearray) → None
readblocks(block_num: int, buf: bytearray, offset: int) → None

קורא נתונים גולמיים מיושרי-בלוק מהכרטיס אל תוך buf. נקודת הכניסה הסטנדרטית של התקן בלוק vfs.AbstractBlockDev שבה משתמשת שכבת מערכת הקבצים.

צורה פשוטה (readblocks(block_num, buf)): קורא בלוקים שלמים החל מאינדקס הבלוק block_num. len(buf) חייב להיות כפולה של גודל בלוק ה-SD (512 בתים).

צורה מורחבת (readblocks(block_num, buf, offset)): קורא len(buf) בתים – לא בהכרח מספר שלם של בלוקים – החל מהבית offset בתוך הבלוק block_num. בשימוש על ידי littlefs ומערכות קבצים אחרות הניתנות למיעון לפי בית.

writeblocks(block_num: int, buf: bytes | bytearray) → None
writeblocks(block_num: int, buf: bytes | bytearray, offset: int) → None

כותב נתונים גולמיים מיושרי-בלוק מ-buf אל הכרטיס. נקודת הכניסה הסטנדרטית של התקן בלוק vfs.AbstractBlockDev שבה משתמשת שכבת מערכת הקבצים.

צורה פשוטה (writeblocks(block_num, buf)): כותב בלוקים שלמים החל מאינדקס הבלוק block_num. len(buf) חייב להיות כפולה של גודל בלוק ה-SD (512 בתים). כל בלוק מושפע נכתב מחדש במלואו.

צורה מורחבת (writeblocks(block_num, buf, offset)): כותב len(buf) בתים – לא בהכרח מספר שלם של בלוקים – החל מהבית offset בתוך הבלוק block_num. בשימוש על ידי littlefs ומערכות קבצים אחרות הניתנות למיעון לפי בית.

ioctl(cmd: int, arg: int) → int | None

נקודת כניסת הבקרה הסטנדרטית של vfs.AbstractBlockDev. נקראת על ידי שכבת מערכת הקבצים בזמן עיגון/ביטול-עיגון ובכל סנכרון. ערכי ה-cmd המזוהים הם:

  • 1 – אתחול. מחזיר 0 בהצלחה.

  • 2 – ביטול אתחול. מחזיר 0 בהצלחה.

  • 3 – סנכרון כל כתיבה ממתינה. מחזיר 0 (מנהל ההתקן SDMMC כותב באופן סינכרוני, אין מה לרוקן).

  • 4 – מחזיר את מספר הבלוקים בהתקן.

  • 5 – מחזיר את גודלו של בלוק בודד (תמיד 512).

  • 6 – מוחק בלוק (ללא-פעולה ב-SD, נשמר לצורך החוזה של vfs.AbstractBlockDev).

  • 7 – מחזיר האם ההתקן תומך במחיקת בלוק (0 ב-SD).

קוראים ישירים בדרך כלל אינם משתמשים במתודה זו – מנהל ההתקן של מערכת הקבצים משגר את כל הקודים הסטנדרטיים אוטומטית ברגע ש-SDCard מעוגן.

init(*args, **kwargs) → None

מאתחל מחדש את ממשק ה-SD מאפס. מקבל את אותם ארגומנטים כמו הבנאי. שימושי לזיהוי מחדש של כרטיס שהוכנס חם בלוחות ללא אות זיהוי-כרטיס, מאחר ש-present() ננעל אחרת בזמן הבנייה. פורט mimxrt בלבד.

deinit() → None

מבטל אתחול של ממשק ה-SD, ומשחרר את בקר ה-SDMMC/USDHC ואת פיני ה-IO שתפס. אובייקט ה-SDCard הופך לבלתי שמיש עד שתיקרא init() שוב. השתמש בו לפני צריבה מחדש של הכרטיס מממשק אחר, או כדי לנתק את המתח לחריץ ביישום המופעל מסוללה. פורט mimxrt בלבד.