class SPIDisplay – מנהל התקן תצוגת SPI¶

המחלקה SPIDisplay מנהלת פאנלי TFT ו-OLED קטנים המחוברים ב-SPI – לרוב ה-OLED מסוג SSD1351 128x160 RGB שעל מגן ה-LCD של OpenMV. מנהל ההתקן מנהל באופן פנימי את אפיק ה-SPI ואת קווי בחירת השבב (chip-select) וה-DC של ה-GPIO, כך שהקוראים מגדירים רק את גאומטריית הפאנל, קצב הרענון וכל דגלי הכיוון. אתחול ייחודי לפאנל (רצפי אוגרים, מסגור של כתיבה ל-RAM) מסופק דרך ארגומנט מילת המפתח controller – העבירו מופע של SSD1351 כדי להניע את מגן ה-LCD, או ממשו מחלקת בקר משלכם עבור פאנלים אחרים.

פריימים מוצגים על ידי קריאה ל-write() עם image.Image. מנהל ההתקן ממיר את המקור ל-RGB565 ומחיל קנה מידה, ROI, לוח צבעים וטרנספורמציות כיוון באופן פנימי, כך שהקורא אינו צריך להתאים מראש את גודל התמונה. ניתן להשאיר את בהירות התאורה האחורית כ-GPIO פשוט של הדלקה/כיבוי (ברירת מחדל) או להניע אותה על ידי DACBacklight / PWMBacklight על ידי העברת אחד מהם כארגומנט מילת המפתח backlight.

דוגמה – שיקוף המצלמה על ה-OLED מסוג SSD1351 של מגן ה-LCD של OpenMV:

import csi
import display

csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize((128, 160))        # matches the SSD1351 panel

lcd = display.SPIDisplay(controller=display.SSD1351())

while True:
    lcd.write(csi0.snapshot())

בנאים¶

class display.SPIDisplay(width: int = 128, height: int = 160, refresh: int = 60, bgr: bool = False, byte_swap: bool = False, hmirror: bool = True, vflip: bool = True, triple_buffer: bool | None = None, *, controller: object | None = None, backlight: object | None = None)¶

width רוחב ה-SPI LCD בפיקסלים (1..32767).

height גובה ה-SPI LCD בפיקסלים (1..32767).

refresh קצב רענון ה-LCD בהרץ (1..120). שולט בקצב שעון ה-SPI.

bgr הגדירו ל-True כדי להחליף בין ערוצי האדום והכחול.

byte_swap הגדירו ל-True כדי להחליף את בתי הפיקסל של RGB565 הנשלחים ל-LCD.

hmirror הגדירו ל-True כדי לשקף אופקית את פלט התצוגה.

vflip הגדירו ל-True כדי להפוך אנכית את פלט התצוגה.

triple_buffer אם True הופך עדכונים למסך ללא חוסמים במחיר של פי 3 מגודל התצוגה ב-RAM. ברירת המחדל תלויה בלוח (מופעל בלוחות עם SDRAM).

controller מילת מפתח בלבד. העבירו מופע של מחלקת שבב בקר כדי לאתחל אותו יחד עם התצוגה. כאשר מסופק, מתבצעות קריאות למתודות init, display_on, display_off ו-ram_write של הבקר (אם קיימות) במקום הפקודות המובנות.

backlight מילת מפתח בלבד. העבירו מודול בקר תאורה אחורית לשימוש. כברירת מחדל התאורה האחורית נשלטת באמצעות פין GPIO.

width() → int¶: מחזיר את רוחב המסך.

height() → int¶: מחזיר את גובה המסך.

refresh() → int¶: מחזיר את קצב הרענון.

bgr() → bool¶: מחזיר האם ערוצי האדום והכחול מוחלפים.

byte_swap() → bool¶: מחזיר האם פיקסלים של RGB565 נשלחים עם בתים הפוכים.

triple_buffer() → bool¶: מחזיר האם חציצה משולשת מאופשרת.

framesize() → int¶: מחזיר את מזהה ה-framesize שהוגדר.

write(image: image.Image, x: int = 0, y: int = 0, x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | image.Image | None = None, alpha_palette: image.Image | None = None, hint: int = 0) → None¶

מציג image כשפינתו השמאלית-עליונה ב-(x, y). ניתן להעביר מחרוזת נתיב במקום תמונה כדי לטעון ולצייר אותה בשלב אחד.

x_scale מקדם קנה מידה בציר ה-x. ערכים שליליים הופכים אופקית. אם y_scale מושמט הוא עוקב אחר x_scale כדי לשמר את יחס הממדים.

y_scale מקדם קנה מידה בציר ה-y. ערכים שליליים הופכים אנכית (דורש triple_buffer=True). אם x_scale מושמט הוא עוקב אחר y_scale.

roi מלבן אזור העניין (x, y, w, h) של תמונת המקור לציור.

rgb_channel ערוץ ה-RGB שיש לחלץ מתמונת מקור RGB565 (0=R, 1=G, 2=B, -1=הכול). טווח: -1..2.

alpha אטימות התמונה. 0 הוא שקוף לחלוטין (שחור), 255 הוא אטום. טווח: 0..255.

color_palette enum של לוח צבעים (למשל image.PALETTE_RAINBOW) או תמונת RGB565 בת 256 פיקסלים המשמשת כטבלת חיפוש צבעים על ערך גווני האפור של המקור. מוחל לאחר חילוץ rgb_channel.

alpha_palette תמונת גווני אפור בת 256 פיקסלים המשמשת כטבלת חיפוש אלפא לכל פיקסל המווסתת את alpha בהתבסס על ערך גווני האפור של המקור.

hint OR לוגי של הדגלים:

image.AREA: שימוש בקנה מידה לפי שטח בעת הקטנה.

image.BILINEAR: שימוש בקנה מידה דו-קווי.

image.BICUBIC: שימוש בקנה מידה דו-קוּבּי.

image.CENTER: מרכוז התמונה על התצוגה (לאחר שינוי קנה המידה).

image.HMIRROR: שיקוף אופקי של התמונה.

image.VFLIP: היפוך אנכי של התמונה.

image.TRANSPOSE: שחלוף התמונה (החלפת x/y).

image.EXTRACT_RGB_CHANNEL_FIRST: החלת חילוץ rgb_channel לפני שינוי קנה המידה.

image.APPLY_COLOR_PALETTE_FIRST: החלת color_palette לפני שינוי קנה המידה.

image.SCALE_ASPECT_KEEP: התאמת קנה מידה כך שתתאים בתוך התצוגה.

image.SCALE_ASPECT_EXPAND: התאמת קנה מידה כך שתמלא את התצוגה (עם חיתוך).

image.SCALE_ASPECT_IGNORE: התאמת קנה מידה כך שתמלא את התצוגה (עם מתיחה).

image.ROTATE_90: סיבוב ב-90 מעלות (VFLIP | TRANSPOSE).

image.ROTATE_180: סיבוב ב-180 מעלות (HMIRROR | VFLIP).

image.ROTATE_270: סיבוב ב-270 מעלות (HMIRROR | TRANSPOSE).

clear(display_off: bool = False) → None¶

מנקה את מסך ה-LCD לשחור.

display_off אם True, מכבה את לוגיקת התצוגה במקום לנקות את חוצץ הפריימים (frame buffer). יש להשבית גם את התאורה האחורית לאחר מכן.

backlight(value: int | None = None) → int | None¶

עם value, מגדיר את עוצמת התאורה האחורית (0=כבוי..100=מלא). ללא ארגומנטים, מחזיר את ערך התאורה האחורית הנוכחי.

אלא אם הועבר בקר DACBacklight או PWMBacklight בעת הבנייה, התאורה האחורית מונעת כפין GPIO ועוברת רק מ-0 (כבוי) לערך שונה מאפס (דולק).

bus_write(cmd: int, args: int | bytes | None = None, *, dcs: bool = False) → None¶: שולח cmd אל התצוגה דרך אפיק ה-SPI, ואחריו באופן אופציונלי args (בית מסוג int או חוצץ (buffer) של בתים). dcs בוחר מסגור DCS כאשר נתמך על ידי הבקר.

bus_read(cmd: int, len: int, args: int | bytes | None = None, *, dcs: bool = False) → bytearray¶: שולח cmd דרך אפיק ה-SPI וקורא בחזרה len בתים, ומחזיר אותם כ-bytearray. args נכתב באופן אופציונלי לפני הקריאה (בית מסוג int או חוצץ (buffer) של בתים). dcs בוחר מסגור DCS כאשר נתמך על ידי הבקר.

ioctl(cmd: int, arg: object | None = None) → object¶: מוציא ioctl cmd ייחודי לבקר עם arg אופציונלי. מעלה ValueError אם התצוגה הבסיסית אינה תומכת ב-ioctl.