`csi` — חיישני מצלמה#

המודול csi הוא הממשק המודרני, מוכוון-העצמים, לחיישן(י) המצלמה שב-OpenMV Cam. כל חיישן פיזי מיוצג על ידי מופע של CSI, כך שלוחות הדמיין הרב-ספקטרלי שמשלבים חיישן צבע עם חיישן תרמי או חיישן אירועים יכולים להפעיל כל אחד מהם באופן עצמאי על ידי העברת cid שונה לבנאי. מצלמות עם חיישן יחיד פשוט יוצרות מופע אחד של CSI.

אובייקט CSI הוא הבעלים של תצורת החיישן המלאה – פורמט פיקסל, framesize / חלון, חשיפה / הגבר (gain) / איזון לבן, שיקוף והיפוך חומרתיים, דפוס בדיקה של פסי צבע, שעון קצב פריימים, ROI לחשיפה אוטומטית, ופקודות ioctl ספציפיות לשבב. פריימים נלכדים באמצעות CSI.snapshot(), שמחזירה image.Image הנתמכת על ידי חוצץ הפריימים (frame buffer).

מודול זה מחליף את המודול הישן sensor (שחשף את אותה פונקציונליות כפונקציות ברמת המודול הקשורות לחיישן מוסתר יחיד). קוד חדש צריך להשתמש ב-CSI.

דוגמת שימוש:

import csi

# Setup camera.
csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.QVGA)
csi0.snapshot(time=2000)  # skip frames

# Take pictures.
while(True):
    csi0.snapshot()

שימוש ב-Asyncio#

לולאת CSI.snapshot() החוסמת שלמעלה אינה משתפת פעולה עם לולאת האירועים של asyncio – בזמן ש-snapshot ממתינה לפריים הבא, כל קורוטינה אחרת בתוכנית קפואה. כדי לאפשר ללולאת לכידה להתקיים יחד עם עבודה מקבילה אחרת (לקוח UART, צופה בלחצן, משימת רשת) עטוף את CSI במתאם קטן שהופך את snapshot לקורוטינה ידידותית ל-await על ידי דגימה של snapshot(blocking=False) והשבת השליטה ללולאת האירועים בין הבדיקות:

import asyncio
import csi


class AsyncCSI:
    def __init__(self, *args, **kwargs):
        self._csi = csi.CSI(*args, **kwargs)

    def __getattr__(self, name):
        return getattr(self._csi, name)

    async def snapshot(self):
        while True:
            img = self._csi.snapshot(blocking=False)
            if img is not None:
                return img
            await asyncio.sleep_ms(0)

__getattr__ מעביר כל מאפיין אחר (reset, pixformat, framesize, כפתורי החיישן) ל-CSI הבסיסי כך שהעוטף הוא תחליף ישיר. הקריאה הלא-חוסמת הראשונה גם מתחילה את לכידת ה-DMA של המצלמה אם היא לא הייתה כבר פעילה, כך שאין צורך באתחול נוסף.

לולאת לכידה משתלבת אז בתוכנית asyncio גדולה יותר פשוט כקורוטינה נוספת:

async def capture_loop(cam):
    while True:
        img = await cam.snapshot()
        # process img here

async def main():
    cam = AsyncCSI()
    cam.reset()
    cam.pixformat(csi.RGB565)
    cam.framesize(csi.QVGA)

    asyncio.create_task(some_other_task())
    await capture_loop(cam)

asyncio.run(main())

הגדרת framebuffers עדיין משמעותית בצורה זו – מצב חוצץ-יחיד גורם ל-snapshot(blocking=False) להחזיר None עד שהפריים הבא נלכד, בעוד שחציצה כפולה או משולשת מחליקה זאת כך שהעוטף בדרך כלל מוצא פריים מחוצץ ממתין בדגימה הראשונה. ראה את אבן הראשה AsyncCSI במדריך ה-asyncio להסבר המלא.

class CSI – ממשק חיישן המצלמה#

המחלקה CSI משמשת לשליטה בחיישן מצלמה.

class csi.CSI(cid: int = -1, delays: bool = True, fflush: bool = True, stream: bool | None = None)#

יוצר אובייקט לתקשורת עם חיישן מצלמה. בלוחות עם מספר חיישנים, ניתן לבחור את אובייקט ה-CSI המסוים על ידי העברת cid כמו csi.LEPTON כדי לבחור מודול חיישן FLIR Lepton. אם cid הוא -1 נבחר החיישן הראשי (בדרך כלל מודול מצלמת צבע בלוחות מרובי-חיישנים).

אם delays הוא False אזי כל השהיות זמן ההתייצבות במנהל ההתקן csi מנוטרלות. כברירת מחדל מנהל התקן החיישן משהה לאחר איפוס / שינוי מצב כדי למנוע החזרת פריימים פגומים על ידי CSI.snapshot. ניטרול ההשהיות מאפשר לך לקבץ עדכונים ולהחיל השהיה אחת בסוף לפני קריאה ל-CSI.snapshot.

אם fflush הוא False אזי השטיפה האוטומטית של חוצץ הפריימים המוזכרת ב-CSI.framebuffers מנוטרלת. הדבר מסיר כל מגבלת זמן על פריימים ב-fifo של חוצץ הפריימים (frame buffer).

stream בוחר האם CSI זה הוא מקור הזרם הנשלח ל-IDE. אם None (ברירת מחדל) ה-CSI הופך למקור הזרם רק אם הוא החיישן הראשי (הלא-משני). העבר True כדי לכפות על CSI זה להיות מקור הזרם, או כל ערך שקרי כדי להשאיר את מקור הזרם הקיים ללא שינוי.

מתודות#

reset(hard: bool = True) → None#: מאתחל את חיישן המצלמה. מבצע איפוס חומרתי על ידי החלפת אות RESET של ה-GPIO למודול המצלמה אם hard הוא True. hard צריך להיות מוגדר ל-false בעת איפוס חיישני מצלמה משניים שחולקים את אותו אות RESET של GPIO כמו המודול הראשי.

shutdown(enable: bool) → None#: מעביר את המצלמה למצב צריכת חשמל נמוכה יותר משינה (אך יש לאפס את המצלמה בעת ההתעוררות).

sleep(enable: bool) → None#: מעביר את המצלמה לשינה אם enable הוא True. אחרת, מעיר אותה בחזרה.

flush() → None#: מעתיק את תוכן חוצץ הפריימים הנוכחי לתצוגה המקדימה של ה-IDE. קרא לזה לאחר CSI.snapshot האחרון אם הסקריפט מסתיים כדי שה-IDE יציג את הפריים האחרון.

snapshot(time: int = -1, frames: int = -1, blocking: bool = True, image: image.Image | None = None) → image.Image | None#

מצלם תמונה באמצעות המצלמה ומחזיר אובייקט image.Image.

אם מועברים time ו/או frames snapshot תחסום למשך אותם time מילישניות ו/או frames שנלכדו מהמצלמה. ניתן להשתמש בשני הארגומנטים בו-זמנית. לאחר שעברו time ו/או frames snapshot תחזיר None.

blocking עשוי להיות False כדי לאפשר התנהגות לא-חוסמת אשר תגרום ל-snapshot להחזיר None כאשר התמונה הבאה מהמצלמה אינה מוכנה במקום להמתין.

image עשוי להיות אובייקט image.Image אחר לעדכון עם התמונה החדשה שנלכדה מהמצלמה במקום החזרת אובייקט image.Image חדש. תוכן התמונה הקודם נכתב מחדש באמצעות העתקה עמוקה.

אם CSI.auto_rotation מופעל מתודה זו תחזיר image.Image שכבר עברה סיבוב.

width() → int#: מחזיר את רוחב רזולוציית החיישן.

height() → int#: מחזיר את גובה רזולוציית החיישן.

cid() → int#: מחזיר את מזהה השבב של מודול המצלמה. השווה מול אחד מ-csi.OV2640, csi.OV5640, csi.OV7670, csi.OV7690, csi.OV7725, csi.OV9650, csi.MT9V022, csi.MT9V024, csi.MT9V032, csi.MT9V034, csi.MT9M114, csi.BOSON320, csi.BOSON640, csi.LEPTON, csi.HM01B0, csi.HM0360, csi.GC2145, csi.GENX320ES, csi.GENX320, csi.PAG7920, csi.PAG7936, csi.PAJ6100, csi.FROGEYE2020, או csi.SOFTCSI.

readable() → bool#: מחזיר True אם יש תמונה מוכנה להחזרה על ידי CSI.snapshot כך שקריאה ל-snapshot לא תחסום.

pixformat(pixformat: int | None = None) → int | None#

מגדיר את פורמט הפיקסל של מודול המצלמה לאחד מ-csi.GRAYSCALE, csi.RGB565, csi.BAYER, csi.YUV422, או csi.JPEG (רק ב-OV2640/OV5640).

מחזיר את ה-pixformat הנוכחי אם נקרא ללא ארגומנטים.

framesize(framesize: int | Tuple[int, int] | None = None) → int | None#

מגדיר את גודל הפריים של מודול המצלמה לאחד מקבועי הגודל (לדוגמה csi.QVGA, csi.VGA, csi.HD, וכו« — ראה את מקטע הקבועים).

לחלופין, ניתן להעביר framesize מותאם אישית כ-tuple (w, h). כאשר CSI.snapshot נקרא ה-framesize המותאם אישית ייבדק מול כללי DMA. בדרך כלל framesizes צריכים להיות כפולה של 8 פיקסלים ו/או 16 בתים.

מחזיר את ה-framesize הנוכחי אם נקרא ללא ארגומנטים.

framerate(rate: int | None = None) → int | None#

מגדיר את קצב הפריימים ב-Hz עבור מודול המצלמה.

מחזיר את ה-framerate הנוכחי אם נקרא ללא ארגומנטים.

הערה

CSI.framerate עובד על ידי השמטת פריימים שמתקבלים ממודול המצלמה כדי לשמור על קצב הפריימים בקצב המצוין או מתחתיו. כברירת מחדל המצלמה תרוץ בקצב הפריימים המקסימלי. אם מיושם עבור חיישן המצלמה המסוים CSI.framerate גם יפחית את קצב הפריימים של חיישן המצלמה באופן פנימי כדי לחסוך בחשמל ולשפר את איכות התמונה על ידי הגדלת חשיפת החיישן. CSI.framerate עלול להתנגש עם CSI.auto_exposure בחלק מהמצלמות.

window(roi: Tuple[int, int] | Tuple[int, int, int, int] | None = None) → Tuple[int, int, int, int] | None#

מגדיר את רזולוציית המצלמה לתת-אזור של הרזולוציה הנוכחית. roi הוא tuple (x, y, w, h). ניתן גם להעביר (w, h) והחלון ימורכז.

מחזיר את ה-tuple (x, y, w, h) הנוכחי אם נקרא ללא ארגומנטים.

gainceiling(gainceiling: int) → bool#

מגדיר את תקרת ההגבר (gainceiling) של תמונת המצלמה לאחד מ-2, 4, 8, 16, 32, 64, או 128.

מחזיר True בהצלחה ו-False בכישלון.

brightness(brightness: int) → bool#

מגדיר את בהירות תמונת המצלמה.

מחזיר True בהצלחה ו-False בכישלון.

contrast(contrast: int) → bool#

מגדיר את הניגודיות של תמונת המצלמה.

מחזיר True בהצלחה ו-False בכישלון.

saturation(saturation: int) → bool#

מגדיר את הרוויה של תמונת המצלמה.

מחזיר True בהצלחה ו-False בכישלון.

quality(quality: int) → bool#

מגדיר את איכות דחיסת ה-JPEG של תמונת המצלמה. 0 - 100.

מחזיר True בהצלחה ו-False בכישלון.

הערה

רק עבור מצלמות OV2640/OV5640.

colorbar(enable: bool) → bool#

מפעיל מצב פסי צבע (True) או מכבה אותו (False). ברירת המחדל היא כבוי.

מחזיר True בהצלחה ו-False בכישלון.

auto_gain(enable: bool, gain_db: float | None = None, gain_db_ceiling: float | None = None) → None#

enable מפעיל בקרת הגבר אוטומטית (True) או מכבה אותה (False). המצלמה מתחילה את פעולתה עם בקרת הגבר אוטומטית מופעלת.

אם enable הוא False ניתן להגדיר הגבר קבוע בדציבלים עם gain_db.

אם enable הוא True ניתן להגדיר את תקרת ההגבר המקסימלית בדציבלים עם gain_db_ceiling עבור אלגוריתם בקרת ההגבר האוטומטית.

הערה

עליך לכבות גם את איזון הלבן אם ברצונך לעקוב אחר צבעים.

gain_db() → float#: מחזיר את ערך ההגבר הנוכחי של המצלמה בדציבלים.

auto_exposure(enable: bool, exposure_us: int = -1) → None#

enable מפעיל בקרת חשיפה אוטומטית (True) או מכבה אותה (False). המצלמה מתחילה את פעולתה עם בקרת חשיפה אוטומטית מופעלת.

אם enable הוא False ניתן להגדיר זמן חשיפה קבוע במיקרושניות עם exposure_us.

הערה

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

exposure_us() → int#: מחזיר את ערך החשיפה הנוכחי של המצלמה במיקרושניות.

auto_whitebal(enable: bool, rgb_gain_db: Tuple[float, float, float] | None = None) → None#

enable מפעיל איזון לבן אוטומטי (True) או מכבה אותו (False). המצלמה מתחילה את פעולתה עם איזון לבן אוטומטי מופעל.

אם enable הוא False ניתן להגדיר הגבר קבוע בדציבלים עבור הערוצים האדום, הירוק והכחול בהתאמה עם rgb_gain_db.

הערה

עליך לכבות גם את בקרת ההגבר אם ברצונך לעקוב אחר צבעים.

rgb_gain_db() → Tuple[float, float, float]#: מחזיר tuple (r, g, b) של ערכי ההגבר הנוכחיים של המצלמה לערוצים האדום, הירוק והכחול בדציבלים.

auto_blc(enable: bool, regs: List[int] | None = None) → None#

מגדיר את כיול רמת השחור האוטומטי (BLC) במצלמה.

enable העבר True או False כדי להפעיל או לכבות את BLC. בדרך כלל תמיד תרצה שזה יהיה מופעל.

regs אם מנוטרל אזי ניתן להגדיר ידנית את ערכי אוגר ה-BLC מקריאה קודמת ל-CSI.blc_regs.

blc_regs() → List[int]#: מחזיר את אוגרי ה-BLC של החיישן כרשימת מספרים שלמים. לשימוש עם CSI.auto_blc.

hmirror(enable: bool | None = None) → bool | None#

מפעיל מצב שיקוף אופקי (True) או מכבה אותו (False). ברירת המחדל היא כבוי.

מחזיר את ההגדרה הנוכחית אם נקרא ללא ארגומנטים.

vflip(enable: bool | None = None) → bool | None#

מפעיל מצב היפוך אנכי (True) או מכבה אותו (False). ברירת המחדל היא כבוי.

מחזיר את ההגדרה הנוכחית אם נקרא ללא ארגומנטים.

transpose(enable: bool | None = None) → bool | None#

מפעיל מצב שחלוף (transpose) (True) או מכבה אותו (False). ברירת המחדל היא כבוי.

vflip=False, hmirror=False, transpose=False -> סיבוב 0 מעלות
vflip=True, hmirror=False, transpose=True -> סיבוב 90 מעלות
vflip=True, hmirror=True, transpose=False -> סיבוב 180 מעלות
vflip=False, hmirror=True, transpose=True -> סיבוב 270 מעלות

מחזיר את ההגדרה הנוכחית אם נקרא ללא ארגומנטים.

auto_rotation(enable: bool | None = None) → bool | None#

מפעיל מצב סיבוב אוטומטי (True) או מכבה אותו (False). ברירת המחדל היא כבוי.

מחזיר את ההגדרה הנוכחית אם נקרא ללא ארגומנטים.

הערה

מתודה זו עובדת רק כאשר ל-OpenMV Cam מותקן imu והיא מופעלת באופן אוטומטי.

framebuffers(count: int | None = None) → int | None#

מגדיר את מספר חוצצי הפריימים המשמשים לקבלת נתוני תמונה. כברירת מחדל OpenMV Cam ינסה להקצות את המספר המקסימלי של חוצצי פריימים שביכולתו. הקצאה מחדש מתרחשת בכל פעם ש-CSI.pixformat, CSI.framesize, או CSI.window נקראים.

count של 1 (חוצץ יחיד), 2 (חוצץ כפול), או 3 (חוצץ משולש) בוחר את מצב הלכידה המתאים. העבר 4 או יותר כדי להעביר את מנהל ההתקן למצב FIFO וידאו שבו count חוצצים נמצאים בתור — שימושי להקלטת וידאו לכרטיס SD. בעת השמטת פריים, כל חוצצי הפריימים מלבד הפעיל מנוקים כך ש-CSI.snapshot תמיד מחזיר פריים עדכני.

מחזיר את ה-count הנוכחי אם נקרא ללא ארגומנטים.

special_effect(effect: int) → bool#

מגדיר את האפקט הדיגיטלי המיוחד (אחד מ-csi.NORMAL או csi.NEGATIVE).

מחזיר True בהצלחה ו-False בכישלון.

lens_correction(enable: bool, radi: int, coef: int) → bool#

enable True כדי להפעיל, False כדי לנטרל. radi רדיוס שלם של פיקסלים לתיקון. coef עוצמת התיקון.

מחזיר True בהצלחה ו-False בכישלון.

vsync_callback(cb: Callable[[int], None] | None = None) → Callable[[int], None] | None#

רושם פונקציית callback cb להרצה (בהקשר פסיקה) בכל פעם שמודול המצלמה מייצר פריים חדש (אך לפני שהפריים מתקבל).

cb מקבל ארגומנט אחד ומועבר לו המצב הנוכחי של פין ה-vsync לאחר השינוי.

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

frame_callback(cb: Callable[[], None] | None = None) → Callable[[], None] | None#

רושם פונקציית callback cb להרצה (בהקשר פסיקה) בכל פעם שמודול המצלמה מייצר פריים חדש והפריים מוכן לקריאה באמצעות CSI.snapshot.

cb אינו מקבל ארגומנטים. השתמש בזה כדי לתזמן קריאת פריים מאוחר יותר עם micropython.schedule().

ioctl(request: int, *args) → Any#

מבצע בקשה ספציפית לחיישן. request הוא אחד מקבועי IOCTL_*; שאר הארגומנטים המיקומיים וערך ההחזרה תלויים בבקשה. הבקשות הנתמכות מקובצות לפי משפחת חיישנים להלן.

כללי (כל חיישן):

ioctl(IOCTL_SET_READOUT_WINDOW, (x, y, w, h))

ioctl(IOCTL_SET_READOUT_WINDOW, (w, h))

מגדיר את חלון הקריאה של החיישן. חלון קטן יותר מעלה את קצב הפריימים על חשבון שדה הראייה.

ioctl(IOCTL_GET_READOUT_WINDOW)

מחזיר את חלון הקריאה הנוכחי כ-tuple (x, y, w, h).

ioctl(IOCTL_SET_TRIGGERED_MODE, enable)

מפעיל (True) או מנטרל (False) מצב מותנה (triggered) ב-MT9V034.

ioctl(IOCTL_GET_TRIGGERED_MODE)

מחזיר את מצב המצב המותנה הנוכחי כ-bool.

ioctl(IOCTL_SET_FOV_WIDE, enable)

כאשר True, מורה ל-framesize() למטב עבור שדה ראייה במקום עבור קצב פריימים.

ioctl(IOCTL_GET_FOV_WIDE)

מחזיר את מצב FOV-wide הנוכחי כ-bool.

ioctl(IOCTL_SET_NIGHT_MODE, enable)

מפעיל (True) או מנטרל (False) את ”מצב הלילה“ של החיישן לתאורה נמוכה. OV7725 ו-OV5640 בלבד.

ioctl(IOCTL_GET_NIGHT_MODE)

מחזיר את מצב הלילה הנוכחי כ-bool.

ioctl(IOCTL_GET_RGB_STATS)

מחזיר tuple בן 4 איברים של סטטיסטיקות ערוצי RGB גולמיות (r, gb, gr, b) שנקראו מהחיישן (בדרך כלל משמש לכוונון איזון לבן).

OV5640 FPC – מיקוד אוטומטי:

ioctl(IOCTL_TRIGGER_AUTO_FOCUS)

מתחיל סריקת מיקוד אוטומטי במודול OV5640 FPC.

ioctl(IOCTL_PAUSE_AUTO_FOCUS)

משהה סריקת מיקוד אוטומטי בתהליך.

ioctl(IOCTL_RESET_AUTO_FOCUS)

מאפס את מיקום המיקוד האוטומטי לברירת המחדל.

ioctl(IOCTL_WAIT_ON_AUTO_FOCUS)

ioctl(IOCTL_WAIT_ON_AUTO_FOCUS, timeout_ms)

חוסם עד שסריקת המיקוד האוטומטי הנוכחית מסתיימת. timeout_ms ברירת המחדל היא 5000 אם הושמט.

FLIR Lepton:

ioctl(IOCTL_LEPTON_GET_WIDTH)

מחזיר את רוחב תמונת ה-Lepton בפיקסלים.

ioctl(IOCTL_LEPTON_GET_HEIGHT)

מחזיר את גובה תמונת ה-Lepton בפיקסלים.

ioctl(IOCTL_LEPTON_GET_RADIOMETRY)

מחזיר את סוג ה-Lepton (רדיומטרי או לא) כ-int.

ioctl(IOCTL_LEPTON_GET_REFRESH)

מחזיר את קצב הרענון של ה-Lepton ב-Hz.

ioctl(IOCTL_LEPTON_GET_RESOLUTION)

מחזיר את רזולוציית ה-ADC של ה-Lepton בביטים.

ioctl(IOCTL_LEPTON_RUN_COMMAND, cmd)

מריץ פקודת FLIR Lepton SDK. cmd הוא מזהה הפקודה בן 16 הביטים שמוגדר על ידי ה-SDK.

ioctl(IOCTL_LEPTON_SET_ATTRIBUTE, attr_id, payload)

כותב מאפיין Lepton SDK. attr_id הוא מזהה המאפיין בן 16 הביטים; payload הוא bytes/bytearray שאורכו חייב להיות כפולה של 16 ביטים.

ioctl(IOCTL_LEPTON_GET_ATTRIBUTE, attr_id, words)

קורא מאפיין Lepton SDK. attr_id הוא מזהה המאפיין בן 16 הביטים; words הוא מספר המילים בנות 16 הביטים לקריאה. מחזיר bytearray.

ioctl(IOCTL_LEPTON_GET_FPA_TEMP)

מחזיר את טמפרטורת מערך מישור המוקד (focal-plane-array) של ה-Lepton במעלות צלזיוס.

ioctl(IOCTL_LEPTON_GET_AUX_TEMP)

מחזיר את הטמפרטורה העזר של ה-Lepton במעלות צלזיוס.

ioctl(IOCTL_LEPTON_SET_MODE, measurement_enabled)

ioctl(IOCTL_LEPTON_SET_MODE, measurement_enabled, high_temp_enabled)

מחליף את ה-Lepton בין AGC לפלט טמפרטורה ישיר. measurement_enabled=True מפעיל פלט טמפרטורה ישיר. הדגל האופציונלי high_temp_enabled בוחר את טווח הטמפרטורות הגבוהות.

ioctl(IOCTL_LEPTON_GET_MODE)

מחזיר tuple בן 2 איברים (measurement_enabled, high_temp_enabled).

ioctl(IOCTL_LEPTON_SET_RANGE, (min_celsius, max_celsius))

מגדיר את טווח הטמפרטורות הממופה ל-0..255 כאשר מצב המדידה מופעל.

ioctl(IOCTL_LEPTON_GET_RANGE)

מחזיר את טווח (min_celsius, max_celsius) הנוכחי.

Himax HM01B0 – זיהוי תנועה:

ioctl(IOCTL_HIMAX_MD_ENABLE, enable)

מפעיל (True) או מנטרל (False) את בלוק זיהוי התנועה שעל החיישן של ה-HM01B0.

ioctl(IOCTL_HIMAX_MD_WINDOW, (x, y, w, h))

ioctl(IOCTL_HIMAX_MD_WINDOW, (w, h))

מגדיר את חלון זיהוי התנועה ב-HM01B0.

ioctl(IOCTL_HIMAX_MD_THRESHOLD, threshold)

מגדיר את סף זיהוי התנועה (0 – 255).

ioctl(IOCTL_HIMAX_MD_CLEAR)

מנקה את תפס פסיקת זיהוי התנועה.

ioctl(IOCTL_HIMAX_OSC_ENABLE, enable)

מפעיל (True) או מנטרל (False) את המתנד הפנימי של ה-HM01B0.

Prophesee GENX320 – חיישן אירועים:

ioctl(IOCTL_GENX320_SET_BIASES, preset)

מחיל ערכה מוגדרת מראש של הטיות (bias). preset הוא אחד מקבועי GENX320_BIASES_*.

ioctl(IOCTL_GENX320_SET_BIAS, bias, value)

מגדיר הטיה (bias) יחידה. bias הוא אחד מקבועי GENX320_BIAS_*; value הוא ההגדרה השלמה.

ioctl(IOCTL_GENX320_SET_AFK, enable)

ioctl(IOCTL_GENX320_SET_AFK, enable, freq_low_hz, freq_high_hz)

מגדיר את מסנן נוגד-ההבהוב (anti-flicker). enable הוא bool; ארגומנטי התדר האופציונליים מגדירים את פס המעבר של המסנן.

ioctl(IOCTL_GENX320_SET_STC, mode)

ioctl(IOCTL_GENX320_SET_STC, mode, arg1[, arg2])

מגדיר את מצב מסנן הניגודיות המרחבי-זמני (spatio-temporal contrast). mode הוא אחד מקבועי GENX320_STC_*; עד שני ארגומנטים נוספים תלויים במצב.

ioctl(IOCTL_GENX320_SET_MODE, mode)

ioctl(IOCTL_GENX320_SET_MODE, mode, evt_res)

מחליף את החיישן בין מצבי פריים ואירוע. mode הוא אחד מקבועי GENX320_MODE_*. עבור מצב אירוע, evt_res הוא אורך ציר השורות של חוצץ האירועים המועבר ל-IOCTL_GENX320_READ_EVENTS.

ioctl(IOCTL_GENX320_READ_EVENTS, buf)

קורא אירועים אל buf, מערך ndarray מסוג uint16 בצורה (EVT_res, 6) שבו EVT_res הוא חזקה של שתיים בין 1024 ל-65536. העמודות הן:

[0] – סוג האירוע (PIX_OFF_EVENT / PIX_ON_EVENT / טריגר).
[1] – שניות.
[2] – מילישניות.
[3] – מיקרושניות.
[4] – קואורדינטת x.
[5] – קואורדינטת y.

מחזיר את מספר האירועים שנכתבו.

ioctl(IOCTL_GENX320_READ_EVENTS_RAW)

מחזיר image.Image המכילה את פריים האירועים הגולמי מה-GENX320.

ioctl(IOCTL_GENX320_CALIBRATE, iterations, sigma)

מכבה פיקסלים שהרעש שלהם גדול מ-sigma סטיות תקן מההתפלגות הנורמלית. iterations הוא מספר שלם של מעברי כיול. מחזיר את מספר הפיקסלים שנוטרלו.

color_palette(palette: int | None = None) → int | None#

מגדיר את פלטת הצבעים לשימוש עבור דברים כמו המרת FLIR Lepton מגווני אפור ל-RGB565 או הדמיית אירועי GENX320. אחד מ-image.PALETTE_RAINBOW, image.PALETTE_IRONBOW, ו-(כאשר נתמך) image.PALETTE_DEPTH, image.PALETTE_EVT_DARK, או image.PALETTE_EVT_LIGHT.

מחזיר את ההגדרה הנוכחית אם נקרא ללא ארגומנטים.

__write_reg(address: int, value: int) → None#: כותב את value לאוגר המצלמה בכתובת address.

הערה
ראה את גיליון הנתונים של המצלמה למידע על האוגרים.

__read_reg(address: int) → int#: קורא את אוגר המצלמה בכתובת address.

הערה
ראה את גיליון הנתונים של המצלמה למידע על האוגרים.

פונקציות#

csi.devices() → List[int]#: מחזיר רשימה של מזהי שבב החיישן שזוהו.

קבועים#

csi.BINARY: int#: פורמט פיקסל BINARY (מפת סיביות). כל פיקסל הוא 1-ביט. שימושי לאחסון מסכה; ניתן להשתמש בו עם image.Image().

csi.GRAYSCALE: int#: פורמט פיקסל GRAYSCALE (Y מתוך YUV422). כל פיקסל הוא 8-ביט.

csi.RGB565: int#: פורמט פיקסל RGB565. כל פיקסל הוא 16-ביט (5-ביט אדום, 6-ביט ירוק, 5-ביט כחול).

csi.BAYER: int#: פורמט פיקסל RAW BAYER.

csi.YUV422: int#: פורמט פיקסל YUV422. כל פיקסל מאוחסן כערך Y בגווני אפור בן 8-ביט ואחריו ערכי צבע U/V לסירוגין בני 8-ביט המשותפים בין שני ערכי Y (Y1, U, Y2, V, …). רק חלק ממתודות עיבוד התמונה עובדות עם YUV422.

csi.JPEG: int#: מצב JPEG. מודול המצלמה מוציא תמונות JPEG דחוסות. השתמש ב-CSI.quality כדי לשלוט באיכות ה-JPEG. עובד רק עבור מצלמות OV2640/OV5640.

csi.OV2640: int#: CSI.cid מחזיר זאת עבור מצלמת OV2640.

csi.OV5640: int#: CSI.cid מחזיר זאת עבור מצלמת OV5640.

csi.OV7670: int#: CSI.cid מחזיר זאת עבור מצלמת OV7670.

csi.OV7690: int#: CSI.cid מחזיר זאת עבור מצלמת OV7690.

csi.OV7725: int#: CSI.cid מחזיר זאת עבור מצלמת OV7725.

csi.OV9650: int#: CSI.cid מחזיר זאת עבור מצלמת OV9650.

csi.MT9V022: int#: CSI.cid מחזיר זאת עבור מצלמת MT9V022.

csi.MT9V024: int#: CSI.cid מחזיר זאת עבור מצלמת MT9V024.

csi.MT9V032: int#: CSI.cid מחזיר זאת עבור מצלמת MT9V032.

csi.MT9V034: int#: CSI.cid מחזיר זאת עבור מצלמת MT9V034.

csi.MT9M114: int#: CSI.cid מחזיר זאת עבור מצלמת MT9M114.

csi.BOSON320: int#: CSI.cid מחזיר זאת עבור מצלמת BOSON 320x256.

csi.BOSON640: int#: CSI.cid מחזיר זאת עבור מצלמת BOSON 640x512.

csi.LEPTON: int#: CSI.cid מחזיר זאת עבור מצלמות LEPTON1/2/3.

csi.HM01B0: int#: CSI.cid מחזיר זאת עבור מצלמת HM01B0.

csi.HM0360: int#: CSI.cid מחזיר זאת עבור מצלמת HM0360.

csi.GC2145: int#: CSI.cid מחזיר זאת עבור מצלמת GC2145.

csi.GENX320ES: int#: CSI.cid מחזיר זאת עבור מצלמת GENX320 (דגימה הנדסית).

csi.GENX320: int#: CSI.cid מחזיר זאת עבור מצלמת GENX320.

csi.PAG7920: int#: CSI.cid מחזיר זאת עבור מצלמת PAG7920.

csi.PAG7936: int#: CSI.cid מחזיר זאת עבור מצלמת PAG7936.

csi.PAJ6100: int#: CSI.cid מחזיר זאת עבור מצלמת PAJ6100.

csi.FROGEYE2020: int#: CSI.cid מחזיר זאת עבור מצלמת FROGEYE2020.

csi.SOFTCSI: int#: CSI.cid מחזיר זאת עבור מצלמת ה-CSI התוכנתית.

csi.NORMAL: int#: מצב Normal עבור CSI.special_effect.

csi.NEGATIVE: int#: מצב Negative עבור CSI.special_effect.

csi.QCIF: int#: רזולוציה 176x144 עבור חיישן המצלמה.

csi.CIF: int#: רזולוציה 352x288 עבור חיישן המצלמה.

csi.QSIF: int#: רזולוציה 176x120 עבור חיישן המצלמה.

csi.SIF: int#: רזולוציה 352x240 עבור חיישן המצלמה.

csi.QQQVGA: int#: רזולוציה 80x60 עבור חיישן המצלמה.

csi.QQVGA: int#: רזולוציה 160x120 עבור חיישן המצלמה.

csi.QVGA: int#: רזולוציה 320x240 עבור חיישן המצלמה.

csi.VGA: int#: רזולוציה 640x480 עבור חיישן המצלמה.

csi.HQVGA: int#: רזולוציה 240x160 עבור חיישן המצלמה.

csi.HVGA: int#: רזולוציה 480x320 עבור חיישן המצלמה.

csi.WVGA: int#: רזולוציה 720x480 עבור חיישן המצלמה MT9V034.

csi.WVGA2: int#: רזולוציה 752x480 עבור חיישן המצלמה MT9V034.

csi.SVGA: int#: רזולוציה 800x600 עבור חיישן המצלמה.

csi.XGA: int#: רזולוציה 1024x768 עבור חיישן המצלמה.

csi.WXGA: int#: רזולוציה 1280x768 עבור חיישן המצלמה MT9M114.

csi.SXGA: int#: רזולוציה 1280x1024 עבור חיישן המצלמה. עובד רק עבור מצלמות OV2640/OV5640.

csi.SXGAM: int#: רזולוציה 1280x960 עבור חיישן המצלמה MT9M114.

csi.UXGA: int#: רזולוציה 1600x1200 עבור חיישן המצלמה. עובד רק עבור מצלמות OV2640/OV5640.

csi.HD: int#: רזולוציה 1280x720 עבור חיישן המצלמה.

csi.FHD: int#: רזולוציה 1920x1080 עבור חיישן המצלמה. עובד רק עבור מצלמת OV5640.

csi.QHD: int#: רזולוציה 2560x1440 עבור חיישן המצלמה. עובד רק עבור מצלמת OV5640.

csi.QXGA: int#: רזולוציה 2048x1536 עבור חיישן המצלמה. עובד רק עבור מצלמת OV5640.

csi.WQXGA: int#: רזולוציה 2560x1600 עבור חיישן המצלמה. עובד רק עבור מצלמת OV5640.

csi.WQXGA2: int#: רזולוציה 2592x1944 עבור חיישן המצלמה. עובד רק עבור מצלמת OV5640.

csi.IOCTL_SET_READOUT_WINDOW: int#: מגדיר את חלון הקריאה. ראה CSI.ioctl.

csi.IOCTL_GET_READOUT_WINDOW: int#: מקבל את חלון הקריאה. ראה CSI.ioctl.

csi.IOCTL_SET_TRIGGERED_MODE: int#: מגדיר מצב מותנה (triggered) עבור ה-MT9V034. ראה CSI.ioctl.

csi.IOCTL_GET_TRIGGERED_MODE: int#: מקבל את מצב המצב המותנה עבור ה-MT9V034. ראה CSI.ioctl.

csi.IOCTL_SET_FOV_WIDE: int#: מאפשר ל-CSI.framesize למטב עבור שדה ראייה על פני FPS. ראה CSI.ioctl.

csi.IOCTL_GET_FOV_WIDE: int#: מחזיר האם CSI.framesize ממטב עבור שדה ראייה על פני FPS. ראה CSI.ioctl.

csi.IOCTL_TRIGGER_AUTO_FOCUS: int#: מפעיל מיקוד אוטומטי במודול המצלמה OV5640 FPC. ראה CSI.ioctl.

csi.IOCTL_PAUSE_AUTO_FOCUS: int#: משהה מיקוד אוטומטי (בזמן ריצה) עבור מודול המצלמה OV5640 FPC. ראה CSI.ioctl.

csi.IOCTL_RESET_AUTO_FOCUS: int#: מאפס מיקוד אוטומטי לברירת המחדל עבור מודול המצלמה OV5640 FPC. ראה CSI.ioctl.

csi.IOCTL_WAIT_ON_AUTO_FOCUS: int#: ממתין לסיום המיקוד האוטומטי במודול המצלמה OV5640 FPC. ראה CSI.ioctl.

csi.IOCTL_SET_NIGHT_MODE: int#: מפעיל או מכבה מצב לילה. מפחית את קצב הפריימים כדי להגדיל את החשיפה באופן דינמי. ראה CSI.ioctl.

csi.IOCTL_GET_NIGHT_MODE: int#: מחזיר האם מצב לילה מופעל. ראה CSI.ioctl.

csi.IOCTL_LEPTON_GET_WIDTH: int#: מחזיר את רוחב רזולוציית תמונת ה-FLIR Lepton בפיקסלים. ראה CSI.ioctl.

csi.IOCTL_LEPTON_GET_HEIGHT: int#: מחזיר את גובה רזולוציית תמונת ה-FLIR Lepton בפיקסלים. ראה CSI.ioctl.

csi.IOCTL_LEPTON_GET_RADIOMETRY: int#: מחזיר את סוג ה-FLIR Lepton (רדיומטרי או לא). ראה CSI.ioctl.

csi.IOCTL_LEPTON_GET_REFRESH: int#: מחזיר את קצב הרענון של ה-FLIR Lepton ב-Hz. ראה CSI.ioctl.

csi.IOCTL_LEPTON_GET_RESOLUTION: int#: מחזיר את רזולוציית ה-ADC של ה-FLIR Lepton בביטים. ראה CSI.ioctl.

csi.IOCTL_LEPTON_RUN_COMMAND: int#: מבצע פקודה בת 16-ביט מ-FLIR Lepton SDK. ראה CSI.ioctl.

csi.IOCTL_LEPTON_SET_ATTRIBUTE: int#: מגדיר מאפיין FLIR Lepton מ-FLIR Lepton SDK. ראה CSI.ioctl.

csi.IOCTL_LEPTON_GET_ATTRIBUTE: int#: מקבל מאפיין FLIR Lepton מ-FLIR Lepton SDK. ראה CSI.ioctl.

csi.IOCTL_LEPTON_GET_FPA_TEMP: int#: מקבל את טמפרטורת ה-FPA של ה-FLIR Lepton בצלזיוס. ראה CSI.ioctl.

csi.IOCTL_LEPTON_GET_AUX_TEMP: int#: מקבל את טמפרטורת ה-AUX של ה-FLIR Lepton בצלזיוס. ראה CSI.ioctl.

csi.IOCTL_LEPTON_SET_MODE: int#: מגדיר את מנהל ההתקן של ה-FLIR Lepton למצב שבו כל פיקסל הוא ערך טמפרטורה. ראה CSI.ioctl.

csi.IOCTL_LEPTON_GET_MODE: int#: מחזיר האם מצב המדידה מופעל עבור חיישן ה-FLIR Lepton. ראה CSI.ioctl.

csi.IOCTL_LEPTON_SET_RANGE: int#: מגדיר את טווח הטמפרטורות הממופה לערכי פיקסל במצב מדידה. ראה CSI.ioctl.

csi.IOCTL_LEPTON_GET_RANGE: int#: מחזיר את טווח הטמפרטורות המשמש למצב מדידה. ראה CSI.ioctl.

csi.IOCTL_HIMAX_MD_ENABLE: int#: שולט בפסיקת זיהוי התנועה ב-HM01B0. ראה CSI.ioctl.

csi.IOCTL_HIMAX_MD_WINDOW: int#: מגדיר את חלון זיהוי התנועה ב-HM01B0. ראה CSI.ioctl.

csi.IOCTL_HIMAX_MD_THRESHOLD: int#: מגדיר את סף זיהוי התנועה ב-HM01B0. ראה CSI.ioctl.

csi.IOCTL_HIMAX_MD_CLEAR: int#: מנקה את פסיקת זיהוי התנועה ב-HM01B0. ראה CSI.ioctl.

csi.IOCTL_HIMAX_OSC_ENABLE: int#: שולט במתנד הפנימי ב-HM01B0. ראה CSI.ioctl.

csi.IOCTL_GET_RGB_STATS: int#: מחזיר את סטטיסטיקות ה-RGB מחיישן המצלמה. ראה CSI.ioctl.

csi.IOCTL_GENX320_SET_BIASES: int#: מגדיר את הטיות (bias) חיישן ה-GENX320 לאחת מהערכות המוגדרות מראש GENX320_BIASES_*. ראה CSI.ioctl. לאחר CSI.reset מנהל ההתקן מחיל את csi.GENX320_BIASES_LOW_NOISE, ולא את csi.GENX320_BIASES_DEFAULT — השתמש ב-ioctl זה כדי לעבור לערכה מוגדרת מראש אחרת כאשר היישום זקוק ליותר רגישות או רוחב פס.

csi.GENX320_BIASES_DEFAULT: int#: ברירות מחדל של גיליון הנתונים של GenX320 — רגישות, רעש ורוחב פס מאוזנים לסצנות כלליות.

csi.GENX320_BIASES_LOW_LIGHT: int#: מכוון לתנאי תאורה נמוכה — שני ספי הניגודיות מורפים לרגישות גבוהה יותר, FO מורד, HPF מנוטרל כך ששינויי בהירות איטיים עדיין נרשמים.

csi.GENX320_BIASES_ACTIVE_MARKER: int#: מכוון למעקב אחר נורות LED מהבהבות בעלות ניגודיות גבוהה (סמנים פעילים) — ספי הניגודיות מועלים כך שרק מעברים חדים מפעילים אירוע, FO ו-HPF מוגברים מאוד למקסום רוחב הפס ודחיית סחיפה איטית של תאורת הסביבה, REFR=0 כך שכל קצה הבהוב נלכד.

csi.GENX320_BIASES_LOW_NOISE: int#: ברירת המחדל של מנהל ההתקן — רגישות נמוכה יותר מ-DEFAULT (ספי ניגודיות מועלים) ו-FO נמוך יותר לפעילות רעש רקע פחותה. הטוב ביותר לסצנות סטטיות או איטיות שבהן אירועי שווא ישתלטו.

csi.GENX320_BIASES_HIGH_SPEED: int#: מכוון לסצנות תנועה מהירה — FO גבוה יותר לרוחב פס פיקסל רחב יותר, HPF גבוה יותר לדחיית שינויים איטיים, REFR גבוה יותר לזמן מת ארוך יותר לאחר כל אירוע כך שהקריאה לא תרווה.

csi.IOCTL_GENX320_SET_BIAS: int#: מגדיר הטיה (bias) יחידה של חיישן ה-GENX320 לערך DAC. העבר קבוע GENX320_BIAS_* (csi.GENX320_BIAS_DIFF_OFF, csi.GENX320_BIAS_DIFF_ON, csi.GENX320_BIAS_FO, csi.GENX320_BIAS_HPF, או csi.GENX320_BIAS_REFR) וערך DAC שלם. כל הטיה היא עצמאית — קרא ל-ioctl זה שוב ושוב כדי לכוונן רק את ההטיות שאתה צריך לאחר החלת ערכה מוגדרת מראש. ראה CSI.ioctl.

csi.GENX320_BIAS_DIFF_OFF: int#: סף ניגודיות של המשווה השלילי — שולט בכמה פיקסל צריך להחשיך לפני ש-csi.PIX_OFF_EVENT נורה. ערך נמוך יותר = רגיש יותר (יותר אירועים).

csi.GENX320_BIAS_DIFF_ON: int#: סף ניגודיות של המשווה החיובי — שולט בכמה פיקסל צריך להבהיר לפני ש-csi.PIX_ON_EVENT נורה. ערך נמוך יותר = רגיש יותר (יותר אירועים).

csi.GENX320_BIAS_FO: int#: תדר חיתוך של מסנן מעביר-נמוכים של הפיקסל — מאזן בין רוחב פס פיקסל (מהירות/השהיה) לבין פעילות רעש רקע. ערך גבוה יותר = תגובת פיקסל מהירה יותר, יותר רעש.

csi.GENX320_BIAS_HPF: int#: תדר חיתוך של מסנן מעביר-גבוהים של הפיקסל — דוחה שינויי בהירות איטיים. ערך גבוה יותר = שינויים איטיים יותר מסוננים החוצה (רק מעברים מהירים נרשמים).

csi.GENX320_BIAS_REFR: int#: תקופת השבירה (refractory) של הפיקסל — זמן מת לאחר שפיקסל פולט אירוע שבמהלכו הוא אינו יכול לירות שוב. ערך גבוה יותר = זמן מת ארוך יותר, פחות אירועים מפיקסל עמוס.

csi.IOCTL_GENX320_SET_AFK: int#: מגדיר את מסנן נוגד-ההבהוב (AFK) של ה-GENX320, אשר דוחה אירועים מפיקסלים המתחלפים בפס תדר מחזורי (תאורה פלואורסצנטית, צגים מונעי-LED, וכו«). העבר enable (1 כדי להפעיל, 0 כדי לנטרל) וכאשר מפעילים, את קצות הפס בהרץ: (enable, freq_low_hz, freq_high_hz). ראה CSI.ioctl.

csi.IOCTL_GENX320_SET_STC: int#: מגדיר את מצב מסנן הניגודיות המרחבי-זמני (STC) של ה-GENX320. העבר קבוע GENX320_STC_* (csi.GENX320_STC_DISABLE, csi.GENX320_STC_ONLY, csi.GENX320_STC_TRAIL_ONLY, csi.GENX320_STC_TRAIL) ואחריו את הסף(ים) שהמצב דורש (במילישניות). ראה CSI.ioctl.

csi.GENX320_STC_DISABLE: int#: מנטרל את מסנן ה-STC/trail של ה-GENX320 — כל אירוע עובר דרכו.

csi.GENX320_STC_ONLY: int#: שומר את האירוע השני של מקבץ; משמיט את האירוע הראשון וכל אירוע מאוחר יותר. מקבל פרמטר אחד, stc_threshold במילישניות — אירועים בתוך אותו חלון מאירוע קודם באותו פיקסל נחשבים חלק מאותו מקבץ.

csi.GENX320_STC_TRAIL_ONLY: int#: שומר את האירוע הראשון של מקבץ; משמיט אירועים עוקבים על אותו פיקסל עד שחלף trail_threshold. מקבל פרמטר אחד, trail_threshold במילישניות.

csi.GENX320_STC_TRAIL: int#: שומר את האירוע הראשון של מקבץ בתוספת קצוות עוקבים — משלב את csi.GENX320_STC_ONLY ואת csi.GENX320_STC_TRAIL_ONLY. מקבל שני פרמטרים, stc_threshold ו-trail_threshold (שניהם ms); החיישן דורש ששניהם יישארו בערך ביחס של 13:1.

csi.IOCTL_GENX320_SET_MODE: int#: מגדיר את מצב הפעולה של ה-GENX320. העבר csi.GENX320_MODE_HISTO עבור היסטוגרמת האירועים שעל השבב (המצלמה מתנהגת כמו מצלמת גווני אפור רגילה בקצב הפריימים המוגדר) או csi.GENX320_MODE_EVENT ואחריו את אורך ציר השורות של ndarray האירועים (חזקה של שתיים בין 1024 ל-65536) עבור הזרמת אירועים גולמית. ראה CSI.ioctl.

csi.GENX320_MODE_HISTO: int#: מצב היסטוגרמה — אירועים נצברים על השבב לתאי ערך לכל פיקסל ומדווחים כפריים בגווני אפור בגודל 320x320 בקצב המוגדר (~20-350 FPS). המצלמה נראית כמו מצלמה רגילה, כך שכל שגרות עיבוד התמונה הסטנדרטיות עובדות ישירות.

csi.GENX320_MODE_EVENT: int#: מצב אירוע — עוקף את ההיסטוגרמה שעל השבב ומזרים אירועים גולמיים לתוך ndarray של numpy עם חותמות זמן במיקרושניות, עבור יישומים הזקוקים לפירוט זמני מלא ולא לפריים מחולק-תאים מראש.

csi.IOCTL_GENX320_READ_EVENTS: int#: קורא אירועים גולמיים לתוך ndarray מסוג uint16 בצורה (EVT_res, 6) (כאשר EVT_res תואם לגודל החוצץ שהועבר ל-csi.IOCTL_GENX320_SET_MODE). העמודות הן [0] סוג אירוע (csi.PIX_OFF_EVENT, csi.PIX_ON_EVENT, csi.EXT_TRIGGER_RISING/FALLING, csi.RST_TRIGGER_RISING/FALLING), [1] חותמת זמן בשניות, [2] מילישניות, [3] מיקרושניות, [4] קואורדינטת X (0-319), [5] קואורדינטת Y (0-319). מחזיר את מספר האירועים שנכתבו לחוצץ, ומשאיר שורות ישנות יותר מעבר לספירה זו ללא שינוי. ראה CSI.ioctl.

csi.IOCTL_GENX320_CALIBRATE: int#: מנטרל אוטומטית פיקסלים חמים — פיקסלים שיורים באופן מזויף אפילו בסצנה סטטית. מנהל ההתקן בונה ספירת פגיעות לכל פיקסל בגודל 320x320, מחשב את הממוצע וסטיית התקן, ומנטרל כל פיקסל שספירתו עולה על mean + sigma * stddev. העבר תקציב ספירת אירועים (אירועים לסכימה לפני חישוב הסטטיסטיקה — גבוה יותר = אומדן אמין יותר, איטי יותר; ~10000 הוא ברירת מחדל טובה) וערך sigma מסוג float (נמוך יותר = אגרסיבי יותר, ~0.5 ברירת מחדל). מחזיר את מספר הפיקסלים שנוטרלו. כוון תחילה את המצלמה לסצנה סטטית כך שאירועים מונעי-תנועה לא ייספרו כנגד פיקסלים שלמעשה תקינים. ראה CSI.ioctl.

csi.IOCTL_GENX320_READ_EVENTS_RAW: int#: מחזיר image.Image של פריים אירועים גולמי מה-GENX320, כשהאירועים עדיין בקידוד הארוז המקורי של השבב — שימושי אם ברצונך להעביר את הזרם הגולמי ל-PC לפענוח לא-מקוון במקום לעבד אותו במצלמה. ראה CSI.ioctl.

csi.PIX_OFF_EVENT: int#: סוג אירוע GENX320 (עמודה [0]) — פיקסל זיהה ירידה בבהירות (סף הניגודיות השלילי נחצה). עמודות [4]/[5] נושאות את ה-X/Y של הפיקסל.

csi.PIX_ON_EVENT: int#: סוג אירוע GENX320 (עמודה [0]) — פיקסל זיהה עלייה בבהירות (סף הניגודיות החיובי נחצה). עמודות [4]/[5] נושאות את ה-X/Y של הפיקסל.

csi.RST_TRIGGER_RISING: int#: סוג אירוע GENX320 (עמודה [0]) — טריגר איפוס-פיקסל, קצה עולה. X/Y אינם בשימוש. אינו נוצר על ידי הקושחה בשלב זה.

csi.RST_TRIGGER_FALLING: int#: סוג אירוע GENX320 (עמודה [0]) — טריגר איפוס-פיקסל, קצה יורד. X/Y אינם בשימוש. אינו נוצר על ידי הקושחה בשלב זה.

csi.EXT_TRIGGER_RISING: int#: סוג אירוע GENX320 (עמודה [0]) — פין הטריגר החיצוני של החיישן ראה קצה עולה. כניסת הטריגר החיצוני של ה-GENX320 מחווטת לקו סנכרון הפריימים של המצלמה, המנותב גם ל-P10 במעבד ולמחבר הפינים. X/Y אינם בשימוש.

csi.EXT_TRIGGER_FALLING: int#: סוג אירוע GENX320 (עמודה [0]) — פין הטריגר החיצוני של החיישן ראה קצה יורד. כניסת הטריגר החיצוני של ה-GENX320 מחווטת לקו סנכרון הפריימים של המצלמה, המנותב גם ל-P10 במעבד ולמחבר הפינים. X/Y אינם בשימוש.

csi — חיישני מצלמה#

שימוש ב-Asyncio#

class CSI – ממשק חיישן המצלמה#

מתודות#

פונקציות#

קבועים#

`csi` — חיישני מצלמה#