`csi` — senzori de cameră¶

Modulul csi este interfața modernă, orientată pe obiecte, către senzorul (senzorii) de cameră de pe o OpenMV Cam. Fiecare senzor fizic este reprezentat de o instanță CSI, astfel încât plăcile cu imager multispectral care asociază un senzor color cu un senzor termic sau de evenimente pot comanda fiecare senzor independent, transmițând un cid diferit constructorului. Camerele cu un singur senzor instanțiază pur și simplu un singur CSI.

Un obiect CSI deține întreaga configurație a senzorului – formatul de pixeli, framesize / fereastra, expunerea / amplificarea (gain) / balansul de alb, oglindirea și răsturnarea hardware, modelul de test cu bare colorate, ceasul ratei de cadre, ROI pentru auto-expunere și comenzile ioctl specifice cipului. Cadrele sunt capturate cu CSI.snapshot(), care returnează o image.Image susținută de tamponul de cadre (frame buffer).

Acest modul înlocuiește modulul vechi sensor (care expunea aceeași funcționalitate prin funcții la nivel de modul legate de un singur senzor ascuns). Codul nou ar trebui să folosească CSI.

Exemplu de utilizare:

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()

Utilizare cu asyncio¶

Bucla blocantă CSI.snapshot() de mai sus nu cooperează cu bucla de evenimente asyncio – în timp ce snapshot așteaptă următorul cadru, orice altă corutină din program este înghețată. Pentru a permite unei bucle de captură să coexiste cu alte sarcini concurente (un client UART, un supraveghetor de buton, o sarcină de rețea), încadrați CSI într-un mic adaptor care transformă snapshot într-o corutină compatibilă cu await, sondând snapshot(blocking=False) și cedând controlul buclei de evenimente între verificări:

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__ redirecționează orice alt atribut (reset, pixformat, framesize, butoanele senzorului) către CSI-ul subiacent, astfel încât învelișul este un înlocuitor direct. Primul apel non-blocant pornește totodată captura DMA a camerei dacă nu rula deja, deci nu este necesară nicio inițializare suplimentară.

O buclă de captură se încadrează apoi într-un program asyncio mai mare ca o simplă altă corutină:

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())

Setarea framebuffers contează în continuare în această formă – modul cu un singur tampon face ca snapshot(blocking=False) să returneze None până la capturarea următorului cadru, în timp ce buffering-ul dublu sau triplu netezește acest lucru, astfel încât învelișul găsește de obicei un cadru tamponat care așteaptă la prima sondare. Vedeți secțiunea finală AsyncCSI din tutorialul asyncio pentru parcurgerea completă.

clasa CSI – Interfață cu senzorul de cameră¶

Clasa CSI este folosită pentru a controla un senzor de cameră.

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

Creează un obiect pentru a comunica cu un senzor de cameră. Pe plăcile cu mai mulți senzori, obiectul CSI specific poate fi selectat transmițând un cid precum csi.LEPTON pentru a selecta un modul de senzor FLIR Lepton. Dacă cid este -1, este selectat senzorul principal (de obicei un modul de cameră color pe plăcile cu mai mulți senzori).

Dacă delays este False, atunci toate întârzierile de stabilizare din driverul csi sunt dezactivate. În mod implicit, driverul senzorului introduce întârzieri după reset / schimbarea modului pentru a preveni returnarea de cadre corupte de către CSI.snapshot. Dezactivarea întârzierilor vă permite să grupați actualizările și să aplicați o singură întârziere la final, înainte de a apela CSI.snapshot.

Dacă fflush este False, atunci golirea automată a tamponului de cadre menționată în CSI.framebuffers este dezactivată. Acest lucru elimină orice limită de timp asupra cadrelor din fifo-ul tamponului de cadre.

stream selectează dacă acest CSI este sursa de flux trimisă către IDE. Dacă este None (implicit), CSI devine sursa de flux doar dacă este senzorul principal (non-auxiliar). Transmiteți True pentru a forța acest CSI să fie sursa de flux sau orice valoare falsă pentru a lăsa neschimbată sursa de flux existentă.

Metode¶

reset(hard: bool = True) → None¶: Inițializează senzorul de cameră. Efectuează un reset hardware comutând semnalul GPIO RESET către modulul de cameră dacă hard este True. hard ar trebui setat la false la resetarea senzorilor de cameră auxiliari care partajează același semnal GPIO RESET ca modulul principal.

shutdown(enable: bool) → None¶: Pune camera într-un mod cu consum mai redus decât modul sleep (dar camera trebuie resetată la trezire).

sleep(enable: bool) → None¶: Pune camera în modul sleep dacă enable este True. În caz contrar, o trezește la loc.

flush() → None¶: Copiază conținutul curent al tamponului de cadre în previzualizarea din IDE. Apelați aceasta după ultimul CSI.snapshot dacă scriptul se termină, astfel încât IDE-ul să afișeze ultimul cadru.

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

Realizează o fotografie folosind camera și returnează un obiect image.Image.

Dacă se transmite time și/sau frames, snapshot va bloca pentru acel număr de milisecunde time și/sau frames capturate de la cameră. Ambele argumente pot fi folosite simultan. După ce time și/sau frames a trecut, snapshot va returna None.

blocking poate fi False pentru a activa comportamentul non-blocant, care va face ca snapshot să returneze None atunci când următoarea imagine de la cameră nu este pregătită, în loc să aștepte.

image poate fi un alt obiect image.Image care să fie actualizat cu noua imagine capturată de la cameră, în loc să se returneze un nou obiect image.Image. Conținutul imaginii anterioare este suprascris printr-o copie profundă.

Dacă CSI.auto_rotation este activată, această metodă va returna o image.Image deja rotită.

width() → int¶: Returnează lățimea rezoluției senzorului.

height() → int¶: Returnează înălțimea rezoluției senzorului.

cid() → int¶: Returnează ID-ul de cip al modulului de cameră. Comparați cu oricare dintre 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 sau csi.SOFTCSI.

readable() → bool¶: Returnează True dacă există o imagine pregătită pentru a fi returnată de CSI.snapshot, astfel încât un apel la snapshot să nu blocheze.

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

Setează formatul de pixeli pentru modulul de cameră la unul dintre csi.GRAYSCALE, csi.RGB565, csi.BAYER, csi.YUV422 sau csi.JPEG (doar pe OV2640/OV5640).

Returnează pixformat-ul curent dacă este apelată fără argumente.

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

Setează dimensiunea cadrului pentru modulul de cameră la una dintre constantele de dimensiune (de ex. csi.QVGA, csi.VGA, csi.HD etc. — vedeți secțiunea de constante).

Alternativ, puteți transmite o dimensiune de cadru personalizată ca un tuplu (w, h). Când CSI.snapshot este apelat, dimensiunea de cadru personalizată va fi evaluată în raport cu regulile DMA. În general, dimensiunile de cadru trebuie să fie un multiplu de 8 pixeli și/sau 16 octeți.

Returnează dimensiunea de cadru curentă dacă este apelată fără argumente.

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

Setează rata de cadre în Hz pentru modulul de cameră.

Returnează rata de cadre curentă dacă este apelată fără argumente.

Notă

CSI.framerate funcționează renunțând la cadrele primite de la modulul de cameră pentru a menține rata de cadre la sau sub valoarea specificată. În mod implicit, camera va rula la rata de cadre maximă. Dacă este implementată pentru senzorul de cameră specific, CSI.framerate va reduce de asemenea rata de cadre a senzorului de cameră intern pentru a economisi energie și a îmbunătăți calitatea imaginii prin creșterea expunerii senzorului. CSI.framerate poate intra în conflict cu CSI.auto_exposure pe unele camere.

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

Setează rezoluția camerei la o sub-regiune a rezoluției curente. roi este un tuplu (x, y, w, h). Puteți de asemenea transmite (w, h), iar fereastra va fi centrată.

Returnează tuplul curent (x, y, w, h) dacă este apelată fără argumente.

gainceiling(gainceiling: int) → bool¶

Setează plafonul de amplificare al imaginii camerei la una dintre valorile 2, 4, 8, 16, 32, 64 sau 128.

Returnează True la succes și False la eșec.

brightness(brightness: int) → bool¶

Setează luminozitatea imaginii camerei.

Returnează True la succes și False la eșec.

contrast(contrast: int) → bool¶

Setează contrastul imaginii camerei.

Returnează True la succes și False la eșec.

saturation(saturation: int) → bool¶

Setează saturația imaginii camerei.

Returnează True la succes și False la eșec.

quality(quality: int) → bool¶

Setează calitatea compresiei JPEG a imaginii camerei. 0 - 100.

Returnează True la succes și False la eșec.

Notă

Doar pentru camerele OV2640/OV5640.

colorbar(enable: bool) → bool¶

Activează modul cu bare colorate (True) sau îl dezactivează (False). Implicit este dezactivat.

Returnează True la succes și False la eșec.

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

enable activează controlul automat al amplificării (True) sau îl dezactivează (False). Camera pornește cu controlul automat al amplificării activat.

Dacă enable este False, puteți seta o amplificare fixă în decibeli cu gain_db.

Dacă enable este True, puteți seta plafonul maxim de amplificare în decibeli cu gain_db_ceiling pentru algoritmul de control automat al amplificării.

Notă

Trebuie să dezactivați și balansul de alb dacă doriți să urmăriți culori.

gain_db() → float¶: Returnează valoarea curentă a amplificării camerei în decibeli.

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

enable activează controlul automat al expunerii (True) sau îl dezactivează (False). Camera pornește cu controlul automat al expunerii activat.

Dacă enable este False, puteți seta un timp de expunere fix în microsecunde cu exposure_us.

Notă

Algoritmii de auto-expunere ai camerei sunt destul de conservatori în privința cât de mult ajustează valoarea expunerii și, în general, evită să modifice prea mult valoarea expunerii. În schimb, modifică mult valoarea amplificării pentru a face față variațiilor de iluminare.

exposure_us() → int¶: Returnează valoarea curentă a expunerii camerei în microsecunde.

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

enable activează balansul de alb automat (True) sau îl dezactivează (False). Camera pornește cu balansul de alb automat activat.

Dacă enable este False, puteți seta o amplificare fixă în decibeli pentru canalele roșu, verde și albastru respectiv cu rgb_gain_db.

Notă

Trebuie să dezactivați și controlul amplificării dacă doriți să urmăriți culori.

rgb_gain_db() → Tuple[float, float, float]¶: Returnează un tuplu (r, g, b) cu valorile curente de amplificare roșu, verde și albastru ale camerei în decibeli.

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

Setează calibrarea automată a nivelului de negru (BLC) pe cameră.

enable transmiteți True sau False pentru a activa sau dezactiva BLC. De obicei doriți întotdeauna ca aceasta să fie activată.

regs dacă este dezactivată, atunci puteți seta manual valorile registrelor BLC dintr-un apel anterior la CSI.blc_regs.

blc_regs() → List[int]¶: Returnează registrele BLC ale senzorului ca o listă de numere întregi. Pentru utilizare cu CSI.auto_blc.

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

Activează modul oglindire orizontală (True) sau îl dezactivează (False). Implicit este dezactivat.

Returnează setarea curentă dacă este apelată fără argumente.

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

Activează modul răsturnare verticală (True) sau îl dezactivează (False). Implicit este dezactivat.

Returnează setarea curentă dacă este apelată fără argumente.

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

Activează modul transpunere (True) sau îl dezactivează (False). Implicit este dezactivat.

vflip=False, hmirror=False, transpose=False -> rotație de 0 grade

vflip=True, hmirror=False, transpose=True -> rotație de 90 de grade

vflip=True, hmirror=True, transpose=False -> rotație de 180 de grade

vflip=False, hmirror=True, transpose=True -> rotație de 270 de grade

Returnează setarea curentă dacă este apelată fără argumente.

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

Activează modul de rotație automată (True) sau îl dezactivează (False). Implicit este dezactivat.

Returnează setarea curentă dacă este apelată fără argumente.

Notă

Această metodă funcționează doar când OpenMV Cam are o imu instalată și este activată automat.

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

Setează numărul de tampoane de cadre folosite pentru a primi datele de imagine. În mod implicit, OpenMV Cam va încerca să aloce numărul maxim de tampoane de cadre posibil. Realocarea are loc ori de câte ori sunt apelate CSI.pixformat, CSI.framesize sau CSI.window.

count de 1 (tampon unic), 2 (tampon dublu) sau 3 (tampon triplu) selectează modul de captură corespunzător. Transmiteți 4 sau mai mult pentru a pune driverul în modul FIFO video, unde sunt puse în coadă count tampoane — util pentru înregistrarea video pe un card SD. La pierderea unui cadru, toate tampoanele de cadre cu excepția celui activ sunt golite, astfel încât CSI.snapshot returnează întotdeauna un cadru recent.

Returnează numărul curent dacă este apelată fără argumente.

special_effect(effect: int) → bool¶

Setează efectul digital special (unul dintre csi.NORMAL sau csi.NEGATIVE).

Returnează True la succes și False la eșec.

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

enable True pentru a activa, False pentru a dezactiva. radi raza întreagă de pixeli de corectat. coef puterea corecției.

Returnează True la succes și False la eșec.

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

Înregistrează funcția de retroapelare (callback) cb pentru a fi executată (în context de întrerupere) ori de câte ori modulul de cameră generează un nou cadru (dar înainte ca acesta să fie recepționat).

cb primește un singur argument și i se transmite starea curentă a pinului vsync după modificare.

Returnează funcția de retroapelare (callback) înregistrată dacă este apelată fără argumente. Transmiteți orice valoare ne-apelabilă pentru a șterge funcția de retroapelare.

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

Înregistrează funcția de retroapelare (callback) cb pentru a fi executată (în context de întrerupere) ori de câte ori modulul de cameră generează un nou cadru, iar cadrul este pregătit pentru citire prin CSI.snapshot.

cb nu primește argumente. Folosiți aceasta pentru a programa citirea unui cadru mai târziu cu micropython.schedule().

Returnează funcția de retroapelare (callback) înregistrată dacă este apelată fără argumente. Transmiteți orice valoare ne-apelabilă pentru a șterge funcția de retroapelare.

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

Execută o cerere specifică senzorului. request este una dintre constantele IOCTL_*; restul argumentelor poziționale și valoarea returnată depind de cerere. Cererile acceptate sunt grupate pe familii de senzori mai jos.

Generic (orice senzor):

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

ioctl(IOCTL_SET_READOUT_WINDOW, (w, h))

Setează fereastra de citire a senzorului. O fereastră mai mică crește rata de cadre cu prețul câmpului vizual.

ioctl(IOCTL_GET_READOUT_WINDOW)

Returnează fereastra de citire curentă ca un tuplu (x, y, w, h).

ioctl(IOCTL_SET_TRIGGERED_MODE, enable)

Activează (True) sau dezactivează (False) modul declanșat pe MT9V034.

ioctl(IOCTL_GET_TRIGGERED_MODE)

Returnează starea curentă a modului declanșat ca un bool.

ioctl(IOCTL_SET_FOV_WIDE, enable)

Când este True, instruiește framesize() să optimizeze pentru câmpul vizual mai degrabă decât pentru rata de cadre.

ioctl(IOCTL_GET_FOV_WIDE)

Returnează starea curentă FOV-wide ca un bool.

ioctl(IOCTL_SET_NIGHT_MODE, enable)

Activează (True) sau dezactivează (False) „modul de noapte” pentru lumină slabă al senzorului. Doar OV7725 și OV5640.

ioctl(IOCTL_GET_NIGHT_MODE)

Returnează starea curentă a modului de noapte ca un bool.

ioctl(IOCTL_GET_RGB_STATS)

Returnează un tuplu de 4 elemente cu statistici brute pe canalele RGB (r, gb, gr, b) citite de la senzor (folosit de obicei pentru ajustarea balansului de alb).

OV5640 FPC – focalizare automată:

ioctl(IOCTL_TRIGGER_AUTO_FOCUS)

Pornește o secvență de focalizare automată pe modulul OV5640 FPC.

ioctl(IOCTL_PAUSE_AUTO_FOCUS)

Pune în pauză o secvență de focalizare automată în curs.

ioctl(IOCTL_RESET_AUTO_FOCUS)

Resetează poziția de focalizare automată la valoarea implicită.

ioctl(IOCTL_WAIT_ON_AUTO_FOCUS)

ioctl(IOCTL_WAIT_ON_AUTO_FOCUS, timeout_ms)

Blochează până când secvența curentă de focalizare automată se termină. timeout_ms este implicit 5000 dacă este omis.

FLIR Lepton:

ioctl(IOCTL_LEPTON_GET_WIDTH)

Returnează lățimea imaginii Lepton în pixeli.

ioctl(IOCTL_LEPTON_GET_HEIGHT)

Returnează înălțimea imaginii Lepton în pixeli.

ioctl(IOCTL_LEPTON_GET_RADIOMETRY)

Returnează tipul senzorului Lepton (radiometric sau nu) ca un int.

ioctl(IOCTL_LEPTON_GET_REFRESH)

Returnează rata de reîmprospătare a senzorului Lepton în Hz.

ioctl(IOCTL_LEPTON_GET_RESOLUTION)

Returnează rezoluția ADC a senzorului Lepton în biți.

ioctl(IOCTL_LEPTON_RUN_COMMAND, cmd)

Execută o comandă din SDK-ul FLIR Lepton. cmd este ID-ul de comandă pe 16 biți definit de SDK.

ioctl(IOCTL_LEPTON_SET_ATTRIBUTE, attr_id, payload)

Scrie un atribut din SDK-ul Lepton. attr_id este ID-ul de atribut pe 16 biți; payload este un bytes/bytearray a cărui lungime trebuie să fie un multiplu de 16 biți.

ioctl(IOCTL_LEPTON_GET_ATTRIBUTE, attr_id, words)

Citește un atribut din SDK-ul Lepton. attr_id este ID-ul de atribut pe 16 biți; words este numărul de cuvinte de 16 biți de citit. Returnează un bytearray.

ioctl(IOCTL_LEPTON_GET_FPA_TEMP)

Returnează temperatura matricei planului focal (FPA) a senzorului Lepton în grade Celsius.

ioctl(IOCTL_LEPTON_GET_AUX_TEMP)

Returnează temperatura auxiliară a senzorului Lepton în grade Celsius.

ioctl(IOCTL_LEPTON_SET_MODE, measurement_enabled)

ioctl(IOCTL_LEPTON_SET_MODE, measurement_enabled, high_temp_enabled)

Comută senzorul Lepton între ieșirea AGC și ieșirea directă de temperatură. measurement_enabled=True activează ieșirea directă de temperatură. Indicatorul opțional high_temp_enabled selectează intervalul de temperatură ridicată.

ioctl(IOCTL_LEPTON_GET_MODE)

Returnează un tuplu de 2 elemente (measurement_enabled, high_temp_enabled).

ioctl(IOCTL_LEPTON_SET_RANGE, (min_celsius, max_celsius))

Setează intervalul de temperatură mapat la 0..255 când modul de măsurare este activat.

ioctl(IOCTL_LEPTON_GET_RANGE)

Returnează intervalul curent (min_celsius, max_celsius).

Himax HM01B0 – detectare de mișcare:

ioctl(IOCTL_HIMAX_MD_ENABLE, enable)

Activează (True) sau dezactivează (False) blocul de detectare a mișcării pe senzor al HM01B0.

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

ioctl(IOCTL_HIMAX_MD_WINDOW, (w, h))

Setează fereastra de detectare a mișcării pe HM01B0.

ioctl(IOCTL_HIMAX_MD_THRESHOLD, threshold)

Setează pragul de detectare a mișcării (0 – 255).

ioctl(IOCTL_HIMAX_MD_CLEAR)

Șterge zăvorul de întrerupere de detectare a mișcării.

ioctl(IOCTL_HIMAX_OSC_ENABLE, enable)

Activează (True) sau dezactivează (False) oscilatorul intern al HM01B0.

Prophesee GENX320 – senzor de evenimente:

ioctl(IOCTL_GENX320_SET_BIASES, preset)

Aplică un preset de polarizări (bias). preset este una dintre constantele GENX320_BIASES_*.

ioctl(IOCTL_GENX320_SET_BIAS, bias, value)

Setează o singură polarizare (bias). bias este una dintre constantele GENX320_BIAS_*; value este valoarea întreagă a setării.

ioctl(IOCTL_GENX320_SET_AFK, enable)

ioctl(IOCTL_GENX320_SET_AFK, enable, freq_low_hz, freq_high_hz)

Configurează filtrul anti-pâlpâire. enable este un bool; argumentele opționale de frecvență setează banda de trecere a filtrului.

ioctl(IOCTL_GENX320_SET_STC, mode)

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

Configurează filtrul de contrast spațio-temporal. mode este una dintre constantele GENX320_STC_*; până la două argumente suplimentare sunt specifice modului.

ioctl(IOCTL_GENX320_SET_MODE, mode)

ioctl(IOCTL_GENX320_SET_MODE, mode, evt_res)

Comută senzorul între modurile cadru și eveniment. mode este una dintre constantele GENX320_MODE_*. Pentru modul eveniment, evt_res este lungimea pe axa rândurilor a tamponului de evenimente transmis către IOCTL_GENX320_READ_EVENTS.

ioctl(IOCTL_GENX320_READ_EVENTS, buf)

Citește evenimente în buf, un ndarray uint16 de formă (EVT_res, 6) unde EVT_res este o putere a lui doi între 1024 și 65536. Coloanele sunt:

[0] – tipul evenimentului (PIX_OFF_EVENT / PIX_ON_EVENT / declanșator).

[1] – secunde.

[2] – milisecunde.

[3] – microsecunde.

[4] – coordonata x.

[5] – coordonata y.

Returnează numărul de evenimente scrise.

ioctl(IOCTL_GENX320_READ_EVENTS_RAW)

Returnează o image.Image care conține cadrul de evenimente brut de la GENX320.

ioctl(IOCTL_GENX320_CALIBRATE, iterations, sigma)

Dezactivează pixelii al căror zgomot depășește sigma abateri standard de la distribuția normală. iterations este numărul întreg de treceri de calibrare. Returnează numărul de pixeli dezactivați.

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

Setează paleta de culori folosită pentru lucruri precum conversia tonurilor de gri FLIR Lepton în RGB565 sau vizualizarea evenimentelor GENX320. Una dintre image.PALETTE_RAINBOW, image.PALETTE_IRONBOW și (când este acceptată) image.PALETTE_DEPTH, image.PALETTE_EVT_DARK sau image.PALETTE_EVT_LIGHT.

Returnează setarea curentă dacă este apelată fără argumente.

__write_reg(address: int, value: int) → None¶: Scrie value în registrul camerei de la address.

Notă

Vedeți fișa tehnică a camerei pentru informații despre registre.

__read_reg(address: int) → int¶: Citește registrul camerei de la address.

Notă

Vedeți fișa tehnică a camerei pentru informații despre registre.

Funcții¶

csi.devices() → List[int]¶: Returnează o listă cu ID-urile de cip ale senzorilor detectați.

Constante¶

csi.BINARY: int¶: Format de pixeli BINARY (bitmap). Fiecare pixel are 1 bit. Util pentru stocarea măștilor; poate fi folosit cu image.Image().

csi.GRAYSCALE: int¶: Format de pixeli GRAYSCALE (Y din YUV422). Fiecare pixel are 8 biți.

csi.RGB565: int¶: Format de pixeli RGB565. Fiecare pixel are 16 biți (5 biți roșu, 6 biți verde, 5 biți albastru).

csi.BAYER: int¶: Format de pixeli imagine RAW BAYER.

csi.YUV422: int¶: Format de pixeli YUV422. Fiecare pixel este stocat ca o valoare Y de 8 biți în tonuri de gri urmată de valori de culoare U/V de 8 biți alternante partajate între două valori Y (Y1, U, Y2, V, …). Doar unele metode de procesare a imaginilor funcționează cu YUV422.

csi.JPEG: int¶: Mod JPEG. Modulul de cameră emite imagini JPEG comprimate. Folosiți CSI.quality pentru a controla calitatea JPEG. Funcționează doar pentru camerele OV2640/OV5640.

csi.OV2640: int¶: CSI.cid returnează aceasta pentru camera OV2640.

csi.OV5640: int¶: CSI.cid returnează aceasta pentru camera OV5640.

csi.OV7670: int¶: CSI.cid returnează aceasta pentru camera OV7670.

csi.OV7690: int¶: CSI.cid returnează aceasta pentru camera OV7690.

csi.OV7725: int¶: CSI.cid returnează aceasta pentru camera OV7725.

csi.OV9650: int¶: CSI.cid returnează aceasta pentru camera OV9650.

csi.MT9V022: int¶: CSI.cid returnează aceasta pentru camera MT9V022.

csi.MT9V024: int¶: CSI.cid returnează aceasta pentru camera MT9V024.

csi.MT9V032: int¶: CSI.cid returnează aceasta pentru camera MT9V032.

csi.MT9V034: int¶: CSI.cid returnează aceasta pentru camera MT9V034.

csi.MT9M114: int¶: CSI.cid returnează aceasta pentru camera MT9M114.

csi.BOSON320: int¶: CSI.cid returnează aceasta pentru camera BOSON 320x256.

csi.BOSON640: int¶: CSI.cid returnează aceasta pentru camera BOSON 640x512.

csi.LEPTON: int¶: CSI.cid returnează aceasta pentru camerele LEPTON1/2/3.

csi.HM01B0: int¶: CSI.cid returnează aceasta pentru camera HM01B0.

csi.HM0360: int¶: CSI.cid returnează aceasta pentru camera HM0360.

csi.GC2145: int¶: CSI.cid returnează aceasta pentru camera GC2145.

csi.GENX320ES: int¶: CSI.cid returnează aceasta pentru camera GENX320 (mostră de inginerie).

csi.GENX320: int¶: CSI.cid returnează aceasta pentru camera GENX320.

csi.PAG7920: int¶: CSI.cid returnează aceasta pentru camera PAG7920.

csi.PAG7936: int¶: CSI.cid returnează aceasta pentru camera PAG7936.

csi.PAJ6100: int¶: CSI.cid returnează aceasta pentru camera PAJ6100.

csi.FROGEYE2020: int¶: CSI.cid returnează aceasta pentru camera FROGEYE2020.

csi.SOFTCSI: int¶: CSI.cid returnează aceasta pentru camera CSI software.

csi.NORMAL: int¶: Mod normal pentru CSI.special_effect.

csi.NEGATIVE: int¶: Mod negativ pentru CSI.special_effect.

csi.QCIF: int¶: Rezoluție 176x144 pentru senzorul de cameră.

csi.CIF: int¶: Rezoluție 352x288 pentru senzorul de cameră.

csi.QSIF: int¶: Rezoluție 176x120 pentru senzorul de cameră.

csi.SIF: int¶: Rezoluție 352x240 pentru senzorul de cameră.

csi.QQQVGA: int¶: Rezoluție 80x60 pentru senzorul de cameră.

csi.QQVGA: int¶: Rezoluție 160x120 pentru senzorul de cameră.

csi.QVGA: int¶: Rezoluție 320x240 pentru senzorul de cameră.

csi.VGA: int¶: Rezoluție 640x480 pentru senzorul de cameră.

csi.HQVGA: int¶: Rezoluție 240x160 pentru senzorul de cameră.

csi.HVGA: int¶: Rezoluție 480x320 pentru senzorul de cameră.

csi.WVGA: int¶: Rezoluție 720x480 pentru senzorul de cameră MT9V034.

csi.WVGA2: int¶: Rezoluție 752x480 pentru senzorul de cameră MT9V034.

csi.SVGA: int¶: Rezoluție 800x600 pentru senzorul de cameră.

csi.XGA: int¶: Rezoluție 1024x768 pentru senzorul de cameră.

csi.WXGA: int¶: Rezoluție 1280x768 pentru senzorul de cameră MT9M114.

csi.SXGA: int¶: Rezoluție 1280x1024 pentru senzorul de cameră. Funcționează doar pentru camerele OV2640/OV5640.

csi.SXGAM: int¶: Rezoluție 1280x960 pentru senzorul de cameră MT9M114.

csi.UXGA: int¶: Rezoluție 1600x1200 pentru senzorul de cameră. Funcționează doar pentru camerele OV2640/OV5640.

csi.HD: int¶: Rezoluție 1280x720 pentru senzorul de cameră.

csi.FHD: int¶: Rezoluție 1920x1080 pentru senzorul de cameră. Funcționează doar pentru camera OV5640.

csi.QHD: int¶: Rezoluție 2560x1440 pentru senzorul de cameră. Funcționează doar pentru camera OV5640.

csi.QXGA: int¶: Rezoluție 2048x1536 pentru senzorul de cameră. Funcționează doar pentru camera OV5640.

csi.WQXGA: int¶: Rezoluție 2560x1600 pentru senzorul de cameră. Funcționează doar pentru camera OV5640.

csi.WQXGA2: int¶: Rezoluție 2592x1944 pentru senzorul de cameră. Funcționează doar pentru camera OV5640.

csi.IOCTL_SET_READOUT_WINDOW: int¶: Setează fereastra de citire. Vedeți CSI.ioctl.

csi.IOCTL_GET_READOUT_WINDOW: int¶: Obține fereastra de citire. Vedeți CSI.ioctl.

csi.IOCTL_SET_TRIGGERED_MODE: int¶: Setează modul declanșat pentru MT9V034. Vedeți CSI.ioctl.

csi.IOCTL_GET_TRIGGERED_MODE: int¶: Obține starea modului declanșat pentru MT9V034. Vedeți CSI.ioctl.

csi.IOCTL_SET_FOV_WIDE: int¶: Activează CSI.framesize să optimizeze pentru câmpul vizual în loc de FPS. Vedeți CSI.ioctl.

csi.IOCTL_GET_FOV_WIDE: int¶: Returnează dacă CSI.framesize optimizează pentru câmpul vizual în loc de FPS. Vedeți CSI.ioctl.

csi.IOCTL_TRIGGER_AUTO_FOCUS: int¶: Declanșează focalizarea automată pe modulul de cameră OV5640 FPC. Vedeți CSI.ioctl.

csi.IOCTL_PAUSE_AUTO_FOCUS: int¶: Pune în pauză focalizarea automată (în timp ce rulează) pentru modulul de cameră OV5640 FPC. Vedeți CSI.ioctl.

csi.IOCTL_RESET_AUTO_FOCUS: int¶: Resetează focalizarea automată la valoarea implicită pentru modulul de cameră OV5640 FPC. Vedeți CSI.ioctl.

csi.IOCTL_WAIT_ON_AUTO_FOCUS: int¶: Așteaptă finalizarea focalizării automate pe modulul de cameră OV5640 FPC. Vedeți CSI.ioctl.

csi.IOCTL_SET_NIGHT_MODE: int¶: Activează sau dezactivează modul de noapte. Reduce rata de cadre pentru a crește expunerea dinamic. Vedeți CSI.ioctl.

csi.IOCTL_GET_NIGHT_MODE: int¶: Returnează dacă modul de noapte este activat. Vedeți CSI.ioctl.

csi.IOCTL_LEPTON_GET_WIDTH: int¶: Returnează lățimea rezoluției imaginii FLIR Lepton în pixeli. Vedeți CSI.ioctl.

csi.IOCTL_LEPTON_GET_HEIGHT: int¶: Returnează înălțimea rezoluției imaginii FLIR Lepton în pixeli. Vedeți CSI.ioctl.

csi.IOCTL_LEPTON_GET_RADIOMETRY: int¶: Returnează tipul senzorului FLIR Lepton (radiometric sau nu). Vedeți CSI.ioctl.

csi.IOCTL_LEPTON_GET_REFRESH: int¶: Returnează rata de reîmprospătare a senzorului FLIR Lepton în Hz. Vedeți CSI.ioctl.

csi.IOCTL_LEPTON_GET_RESOLUTION: int¶: Returnează rezoluția ADC a senzorului FLIR Lepton în biți. Vedeți CSI.ioctl.

csi.IOCTL_LEPTON_RUN_COMMAND: int¶: Execută o comandă pe 16 biți din SDK-ul FLIR Lepton. Vedeți CSI.ioctl.

csi.IOCTL_LEPTON_SET_ATTRIBUTE: int¶: Setează un atribut FLIR Lepton din SDK-ul FLIR Lepton. Vedeți CSI.ioctl.

csi.IOCTL_LEPTON_GET_ATTRIBUTE: int¶: Obține un atribut FLIR Lepton din SDK-ul FLIR Lepton. Vedeți CSI.ioctl.

csi.IOCTL_LEPTON_GET_FPA_TEMP: int¶: Obține temperatura FPA a senzorului FLIR Lepton în Celsius. Vedeți CSI.ioctl.

csi.IOCTL_LEPTON_GET_AUX_TEMP: int¶: Obține temperatura AUX a senzorului FLIR Lepton în Celsius. Vedeți CSI.ioctl.

csi.IOCTL_LEPTON_SET_MODE: int¶: Setează driverul FLIR Lepton într-un mod în care fiecare pixel este o valoare de temperatură. Vedeți CSI.ioctl.

csi.IOCTL_LEPTON_GET_MODE: int¶: Returnează dacă modul de măsurare este activat pentru senzorul FLIR Lepton. Vedeți CSI.ioctl.

csi.IOCTL_LEPTON_SET_RANGE: int¶: Setează intervalul de temperatură mapat la valorile pixelilor în modul de măsurare. Vedeți CSI.ioctl.

csi.IOCTL_LEPTON_GET_RANGE: int¶: Returnează intervalul de temperatură folosit pentru modul de măsurare. Vedeți CSI.ioctl.

csi.IOCTL_HIMAX_MD_ENABLE: int¶: Controlează întreruperea de detectare a mișcării pe HM01B0. Vedeți CSI.ioctl.

csi.IOCTL_HIMAX_MD_WINDOW: int¶: Setează fereastra de detectare a mișcării pe HM01B0. Vedeți CSI.ioctl.

csi.IOCTL_HIMAX_MD_THRESHOLD: int¶: Setează pragul de detectare a mișcării pe HM01B0. Vedeți CSI.ioctl.

csi.IOCTL_HIMAX_MD_CLEAR: int¶: Șterge întreruperea de detectare a mișcării pe HM01B0. Vedeți CSI.ioctl.

csi.IOCTL_HIMAX_OSC_ENABLE: int¶: Controlează oscilatorul intern pe HM01B0. Vedeți CSI.ioctl.

csi.IOCTL_GET_RGB_STATS: int¶: Returnează statisticile RGB de la senzorul de cameră. Vedeți CSI.ioctl.

csi.IOCTL_GENX320_SET_BIASES: int¶: Setează polarizările (bias) senzorului GENX320 la unul dintre preset-urile GENX320_BIASES_*. Vedeți CSI.ioctl. După CSI.reset, driverul aplică csi.GENX320_BIASES_LOW_NOISE, nu csi.GENX320_BIASES_DEFAULT — folosiți acest ioctl pentru a comuta la un preset diferit când aplicația necesită mai multă sensibilitate sau lățime de bandă.

csi.GENX320_BIASES_DEFAULT: int¶: Valori implicite din fișa tehnică GenX320 — sensibilitate, zgomot și lățime de bandă echilibrate pentru scene generale.

csi.GENX320_BIASES_LOW_LIGHT: int¶: Reglat pentru condiții de lumină slabă — ambele praguri de contrast sunt relaxate pentru o sensibilitate mai mare, FO redus, HPF dezactivat astfel încât schimbările lente de luminozitate să se înregistreze totuși.

csi.GENX320_BIASES_ACTIVE_MARKER: int¶: Reglat pentru urmărirea LED-urilor clipitoare cu contrast ridicat (markeri activi) — pragurile de contrast sunt ridicate astfel încât doar tranzițiile bruște să declanșeze, FO și HPF ridicate la maximum pentru a maximiza lățimea de bandă și a respinge derivă lentă a ambianței, REFR=0 astfel încât fiecare muchie de clipire să fie capturată.

csi.GENX320_BIASES_LOW_NOISE: int¶: Valoarea implicită a driverului — sensibilitate mai mică decât DEFAULT (praguri de contrast ridicate) și un FO mai mic pentru mai puțină activitate de zgomot de fundal. Cel mai potrivit pentru scene statice sau lente, unde evenimentele false ar domina.

csi.GENX320_BIASES_HIGH_SPEED: int¶: Reglat pentru scene cu mișcare rapidă — FO mai mare pentru lățime de bandă mai mare a pixelilor, HPF mai mare pentru a respinge schimbările lente, REFR mai mare pentru un timp mort mai lung după fiecare eveniment, astfel încât citirea să nu se satureze.

csi.IOCTL_GENX320_SET_BIAS: int¶: Setează o singură polarizare (bias) a senzorului GENX320 la o valoare DAC. Transmiteți o constantă GENX320_BIAS_* (csi.GENX320_BIAS_DIFF_OFF, csi.GENX320_BIAS_DIFF_ON, csi.GENX320_BIAS_FO, csi.GENX320_BIAS_HPF sau csi.GENX320_BIAS_REFR) și o valoare DAC întreagă. Fiecare polarizare este independentă — apelați acest ioctl în mod repetat pentru a ajusta doar polarizările de care aveți nevoie după aplicarea unui preset. Vedeți CSI.ioctl.

csi.GENX320_BIAS_DIFF_OFF: int¶: Pragul de contrast al comparatorului negativ — controlează cât de mult trebuie să se întunece un pixel înainte ca un csi.PIX_OFF_EVENT să se declanșeze. Valoare mai mică = mai sensibil (mai multe evenimente).

csi.GENX320_BIAS_DIFF_ON: int¶: Pragul de contrast al comparatorului pozitiv — controlează cât de mult trebuie să se lumineze un pixel înainte ca un csi.PIX_ON_EVENT să se declanșeze. Valoare mai mică = mai sensibil (mai multe evenimente).

csi.GENX320_BIAS_FO: int¶: Frecvența de tăiere trece-jos a pixelului — compensează lățimea de bandă a pixelului (viteză/latență) față de activitatea de zgomot de fundal. Valoare mai mare = răspuns mai rapid al pixelului, mai mult zgomot.

csi.GENX320_BIAS_HPF: int¶: Frecvența de tăiere trece-sus a pixelului — respinge schimbările lente de luminozitate. Valoare mai mare = schimbările lente sunt filtrate (doar tranzițiile rapide se înregistrează).

csi.GENX320_BIAS_REFR: int¶: Perioada refractară a pixelului — timp mort după ce un pixel emite un eveniment, în timpul căruia nu poate să se declanșeze din nou. Valoare mai mare = timp mort mai lung, mai puține evenimente de la un pixel ocupat.

csi.IOCTL_GENX320_SET_AFK: int¶: Setează filtrul anti-pâlpâire (AFK) al GENX320, care respinge evenimentele de la pixelii care comută la o bandă de frecvență periodică (iluminat fluorescent, afișaje conduse de LED-uri etc.). Transmiteți enable (1 pentru a activa, 0 pentru a dezactiva) și, la activare, marginile benzii în herți: (enable, freq_low_hz, freq_high_hz). Vedeți CSI.ioctl.

csi.IOCTL_GENX320_SET_STC: int¶: Setează modul filtrului de contrast spațio-temporal (STC) al GENX320. Transmiteți o constantă GENX320_STC_* (csi.GENX320_STC_DISABLE, csi.GENX320_STC_ONLY, csi.GENX320_STC_TRAIL_ONLY, csi.GENX320_STC_TRAIL) urmată de pragul (pragurile) cerut(e) de mod (în milisecunde). Vedeți CSI.ioctl.

csi.GENX320_STC_DISABLE: int¶: Dezactivează filtrul STC/trail al GENX320 — fiecare eveniment trece prin filtru.

csi.GENX320_STC_ONLY: int¶: Păstrează al doilea eveniment al unei rafale; renunță la primul eveniment și la orice evenimente ulterioare. Primește un parametru, stc_threshold în milisecunde — evenimentele din acea fereastră de timp față de un eveniment anterior pe același pixel sunt considerate parte a aceleiași rafale.

csi.GENX320_STC_TRAIL_ONLY: int¶: Păstrează primul eveniment al unei rafale; renunță la evenimentele ulterioare pe același pixel până când a trecut trail_threshold. Primește un parametru, trail_threshold în milisecunde.

csi.GENX320_STC_TRAIL: int¶: Păstrează primul eveniment al unei rafale plus muchiile ulterioare — combină csi.GENX320_STC_ONLY și csi.GENX320_STC_TRAIL_ONLY. Primește doi parametri, stc_threshold și trail_threshold (ambii în ms); senzorul cere ca cele două să rămână într-un raport de aproximativ 13:1.

csi.IOCTL_GENX320_SET_MODE: int¶: Setează modul de operare al GENX320. Transmiteți csi.GENX320_MODE_HISTO pentru histograma de evenimente de pe cip (camera se comportă ca o cameră obișnuită în tonuri de gri la rata de cadre configurată) sau csi.GENX320_MODE_EVENT urmat de lungimea pe axa rândurilor a ndarray-ului de evenimente (o putere a lui doi între 1024 și 65536) pentru fluxul brut de evenimente. Vedeți CSI.ioctl.

csi.GENX320_MODE_HISTO: int¶: Mod histogramă — evenimentele sunt acumulate pe cip în compartimente per pixel și raportate ca un cadru în tonuri de gri 320x320 la rata configurată (~20-350 FPS). Camera arată ca o cameră obișnuită, deci toate rutinele standard de procesare a imaginilor funcționează direct.

csi.GENX320_MODE_EVENT: int¶: Mod eveniment — ocolește histograma de pe cip și transmite evenimente brute într-un ndarray numpy cu marcaje temporale în microsecunde, pentru aplicații care au nevoie de detaliu temporal complet în loc de un cadru pre-compartimentat.

csi.IOCTL_GENX320_READ_EVENTS: int¶: Citește evenimente brute într-un ndarray uint16 de formă (EVT_res, 6) (cu EVT_res corespunzând dimensiunii tamponului transmise către csi.IOCTL_GENX320_SET_MODE). Coloanele sunt [0] tipul evenimentului (csi.PIX_OFF_EVENT, csi.PIX_ON_EVENT, csi.EXT_TRIGGER_RISING/FALLING, csi.RST_TRIGGER_RISING/FALLING), [1] marcaj temporal în secunde, [2] milisecunde, [3] microsecunde, [4] coordonata X (0-319), [5] coordonata Y (0-319). Returnează numărul de evenimente scrise în tampon, lăsând neatinse rândurile mai vechi de dincolo de acel număr. Vedeți CSI.ioctl.

csi.IOCTL_GENX320_CALIBRATE: int¶: Dezactivează automat pixelii fierbinți — pixeli care se declanșează spurios chiar și pe o scenă statică. Driverul construiește un contor de loviri per pixel 320x320, calculează media și abaterea standard și dezactivează orice pixel al cărui contor depășește mean + sigma * stddev. Transmiteți un buget de număr de evenimente (evenimente de numărat înainte de calcularea statisticilor — mai mare = estimare mai fiabilă, mai lent; ~10000 este o valoare implicită bună) și un float sigma (mai mic = mai agresiv, ~0.5 implicit). Returnează numărul de pixeli dezactivați. Îndreptați mai întâi camera spre o scenă statică, astfel încât evenimentele generate de mișcare să nu fie numărate împotriva pixelilor care sunt de fapt în regulă. Vedeți CSI.ioctl.

csi.IOCTL_GENX320_READ_EVENTS_RAW: int¶: Returnează o image.Image cu cadru de evenimente brut de la GENX320, cu evenimentele încă în codificarea nativă împachetată a cipului — util dacă doriți să redirecționați fluxul brut către un PC pentru decodare offline în loc să îl procesați pe cameră. Vedeți CSI.ioctl.

csi.PIX_OFF_EVENT: int¶: Tip de eveniment GENX320 (coloana [0]) — un pixel a detectat o scădere de luminozitate (pragul de contrast negativ a fost depășit). Coloanele [4]/[5] poartă X/Y ale pixelului.

csi.PIX_ON_EVENT: int¶: Tip de eveniment GENX320 (coloana [0]) — un pixel a detectat o creștere de luminozitate (pragul de contrast pozitiv a fost depășit). Coloanele [4]/[5] poartă X/Y ale pixelului.

csi.RST_TRIGGER_RISING: int¶: Tip de eveniment GENX320 (coloana [0]) — declanșator de resetare a pixelilor, muchie ascendentă. X/Y nu sunt folosite. Nu este generat de firmware în acest moment.

csi.RST_TRIGGER_FALLING: int¶: Tip de eveniment GENX320 (coloana [0]) — declanșator de resetare a pixelilor, muchie descendentă. X/Y nu sunt folosite. Nu este generat de firmware în acest moment.

csi.EXT_TRIGGER_RISING: int¶: Tip de eveniment GENX320 (coloana [0]) — pinul de declanșare extern al senzorului a văzut o muchie ascendentă. Intrarea de declanșare externă a GENX320 este conectată la linia de sincronizare a cadrelor camerei, rutată de asemenea la P10 de pe procesor și la conectorul de pini. X/Y nu sunt folosite.

csi.EXT_TRIGGER_FALLING: int¶: Tip de eveniment GENX320 (coloana [0]) — pinul de declanșare extern al senzorului a văzut o muchie descendentă. Intrarea de declanșare externă a GENX320 este conectată la linia de sincronizare a cadrelor camerei, rutată de asemenea la P10 de pe procesor și la conectorul de pini. X/Y nu sunt folosite.

csi — senzori de cameră¶

Utilizare cu asyncio¶

clasa CSI – Interfață cu senzorul de cameră¶

Metode¶

Funcții¶

Constante¶

`csi` — senzori de cameră¶