`csi` — kamerasensorer#

Modulen csi är det moderna, objektorienterade gränssnittet till kamerasensorn/-sensorerna på en OpenMV Cam. Varje fysisk sensor representeras av en CSI-instans, så de multispektrala avbildarkorten som parar en färgsensor med en värme- eller händelsesensor kan styra var och en oberoende genom att skicka olika cid till konstruktorn. Kameror med en enda sensor instansierar bara en CSI.

Ett CSI-objekt äger hela sensorkonfigurationen – pixelformat, bildstorlek/fönster, exponering/förstärkning/vitbalans, hårdvaruspegling och -vändning, testmönster med färgstaplar, klocka för bildfrekvens, ROI för autoexponering och chipspecifika ioctl-kommandon. Bildrutor fångas med CSI.snapshot(), som returnerar en image.Image som backas upp av bildbufferten.

Denna modul ersätter den äldre sensor-modulen (som exponerade samma funktionalitet som funktioner på modulnivå knutna till en enda dold sensor). Ny kod bör använda CSI.

Exempel på användning:

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

Användning med asyncio#

Den blockerande CSI.snapshot()-slingan ovan samarbetar inte med asyncio-händelseslingan – medan snapshot väntar på nästa bildruta är alla andra coroutiner i programmet frusna. För att låta en infångningsslinga samexistera med annat samtidigt arbete (en UART-klient, en knappbevakare, en nätverksuppgift) kan du linda in CSI i en liten adapter som gör snapshot till en await-vänlig coroutine genom att polla snapshot(blocking=False) och lämna över kontrollen till händelseslingan mellan kontrollerna:

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__ vidarebefordrar alla andra attribut (reset, pixformat, framesize, sensorrattarna) till den underliggande CSI så att omslaget är en direkt ersättning. Det första icke-blockerande anropet startar också kamerans DMA-infångning om den inte redan körde, så ingen extra uppstart behövs.

En infångningsslinga passar sedan in i ett större asyncio-program som ännu en coroutine:

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

Inställningen framebuffers har fortfarande betydelse i denna form – enkelbuffertläge gör att snapshot(blocking=False) returnerar None tills nästa bildruta fångats, medan dubbel- eller trippelbuffring jämnar ut det så att omslaget vanligtvis hittar en buffrad bildruta som väntar vid första pollningen. Se AsyncCSI-avslutningen i asyncio-handledningen för en fullständig genomgång.

class CSI – Camera Sensor Interface#

Klassen CSI används för att styra en kamerasensor.

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

Skapar ett objekt för att kommunicera med en kamerasensor. På kort med flera sensorer kan det specifika CSI-objektet väljas genom att skicka ett cid som csi.LEPTON för att välja en FLIR Lepton-sensormodul. Om cid är -1 väljs den primära sensorn (vanligtvis en färgkameramodul på kort med flera sensorer).

Om delays är False inaktiveras alla insvängningsfördröjningar i csi-drivrutinen. Som standard fördröjer sensordrivrutinen efter återställning/lägesbyte för att förhindra att korrupta bildrutor returneras av CSI.snapshot. Att inaktivera fördröjningar låter dig samla uppdateringar och tillämpa en enda fördröjning i slutet innan du anropar CSI.snapshot.

Om fflush är False inaktiveras den automatiska tömningen av bildbufferten som nämns i CSI.framebuffers. Detta tar bort all tidsgräns för bildrutor i bildbuffertens fifo.

stream väljer om denna CSI är strömkällan som skickas till IDE:n. Om None (standard) blir CSI:n strömkälla endast om den är den primära (icke-extra) sensorn. Skicka True för att tvinga denna CSI att vara strömkällan, eller valfritt falskt värde för att lämna den befintliga strömkällan oförändrad.

Metoder#

reset(hard: bool = True) → None#: Initierar kamerasensorn. Utför en hårdvaruåterställning genom att växla RESET-signalens GPIO till kameramodulen om hard är True. hard bör sättas till false vid återställning av extra kamerasensorer som delar samma RESET-signal-GPIO som den primära modulen.

shutdown(enable: bool) → None#: Sätter kameran i ett lägre energiläge än viloläge (men kameran måste återställas när den väcks).

sleep(enable: bool) → None#: Sätter kameran i viloläge om enable är True. Annars väcks den igen.

flush() → None#: Kopierar det aktuella bildbuffertinnehållet till IDE-förhandsgranskningen. Anropa detta efter den sista CSI.snapshot om skriptet avslutas så att IDE:n visar den sista bildrutan.

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

Tar en bild med kameran och returnerar ett image.Image-objekt.

Om time och/eller frames skickas kommer snapshot att blockera i så många time millisekunder och/eller frames infångade från kameran. Båda argumenten kan användas samtidigt. Efter att time och/eller frames har passerat returnerar snapshot None.

blocking kan vara False för att aktivera icke-blockerande beteende, vilket gör att snapshot returnerar None när nästa bild från kameran inte är klar i stället för att vänta.

image kan vara ett annat image.Image-objekt som uppdateras med den nya bilden som fångats från kameran i stället för att returnera ett nytt image.Image-objekt. Det tidigare bildinnehållet skrivs över via en djupkopia.

Om CSI.auto_rotation är aktiverat returnerar denna metod en redan roterad image.Image.

width() → int#: Returnerar sensorns upplösningsbredd.

height() → int#: Returnerar sensorns upplösningshöjd.

cid() → int#: Returnerar kameramodulens chip-ID. Jämför mot någon av 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 eller csi.SOFTCSI.

readable() → bool#: Returnerar True om det finns en bild redo att returneras av CSI.snapshot så att ett anrop till snapshot inte blockerar.

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

Ställer in pixelformatet för kameramodulen till ett av csi.GRAYSCALE, csi.RGB565, csi.BAYER, csi.YUV422 eller csi.JPEG (endast på OV2640/OV5640).

Returnerar det aktuella pixformat om den anropas utan argument.

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

Ställer in bildstorleken för kameramodulen till en av storlekskonstanterna (t.ex. csi.QVGA, csi.VGA, csi.HD osv. — se avsnittet om konstanter).

Alternativt kan du skicka en anpassad bildstorlek som en (w, h)-tupel. När CSI.snapshot anropas utvärderas den anpassade bildstorleken mot DMA-regler. Generellt måste bildstorlekar vara en multipel av 8 pixlar och/eller 16 byte.

Returnerar den aktuella bildstorleken om den anropas utan argument.

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

Ställer in bildfrekvensen i Hz för kameramodulen.

Returnerar den aktuella bildfrekvensen om den anropas utan argument.

Observera

CSI.framerate fungerar genom att kasta bildrutor som tas emot av kameramodulen för att hålla bildfrekvensen vid eller under den angivna frekvensen. Som standard körs kameran på maximal bildfrekvens. Om det är implementerat för den specifika kamerasensorn kommer CSI.framerate även att internt minska kamerasensorns bildfrekvens för att spara ström och förbättra bildkvaliteten genom att öka sensorns exponering. CSI.framerate kan stå i konflikt med CSI.auto_exposure på vissa kameror.

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

Ställer in kamerans upplösning till en delregion av den aktuella upplösningen. roi är en (x, y, w, h)-tupel. Du kan också skicka (w, h) så centreras fönstret.

Returnerar den aktuella (x, y, w, h)-tupeln om den anropas utan argument.

gainceiling(gainceiling: int) → bool#

Ställer in kamerabildens förstärkningstak till ett av 2, 4, 8, 16, 32, 64 eller 128.

Returnerar True vid framgång och False vid misslyckande.

brightness(brightness: int) → bool#

Ställer in kamerabildens ljusstyrka.

Returnerar True vid framgång och False vid misslyckande.

contrast(contrast: int) → bool#

Ställer in kamerabildens kontrast.

Returnerar True vid framgång och False vid misslyckande.

saturation(saturation: int) → bool#

Ställer in kamerabildens mättnad.

Returnerar True vid framgång och False vid misslyckande.

quality(quality: int) → bool#

Ställer in kamerabildens JPEG-komprimeringskvalitet. 0 - 100.

Returnerar True vid framgång och False vid misslyckande.

Observera

Endast för OV2640/OV5640-kamerorna.

colorbar(enable: bool) → bool#

Slår på (True) eller av (False) färgstapelsläge. Standard är av.

Returnerar True vid framgång och False vid misslyckande.

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

enable slår på (True) eller av (False) automatisk förstärkningsstyrning. Kameran startar med automatisk förstärkningsstyrning på.

Om enable är False kan du ställa in en fast förstärkning i decibel med gain_db.

Om enable är True kan du ställa in det maximala förstärkningstaket i decibel med gain_db_ceiling för algoritmen för automatisk förstärkningsstyrning.

Observera

Du måste även stänga av vitbalansen om du vill spåra färger.

gain_db() → float#: Returnerar kamerans aktuella förstärkningsvärde i decibel.

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

enable slår på (True) eller av (False) automatisk exponeringsstyrning. Kameran startar med automatisk exponeringsstyrning på.

Om enable är False kan du ställa in en fast exponeringstid i mikrosekunder med exposure_us.

Observera

Kamerans algoritmer för autoexponering är ganska konservativa med hur mycket de justerar exponeringsvärdet och undviker generellt att ändra exponeringsvärdet särskilt mycket. I stället ändrar de förstärkningsvärdet mycket för att hantera föränderlig belysning.

exposure_us() → int#: Returnerar kamerans aktuella exponeringsvärde i mikrosekunder.

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

enable slår på (True) eller av (False) automatisk vitbalans. Kameran startar med automatisk vitbalans på.

Om enable är False kan du ställa in en fast förstärkning i decibel för de röda, gröna och blå kanalerna respektive med rgb_gain_db.

Observera

Du måste även stänga av förstärkningsstyrningen om du vill spåra färger.

rgb_gain_db() → Tuple[float, float, float]#: Returnerar en tupel (r, g, b) med kamerans aktuella röda, gröna och blå förstärkningsvärden i decibel.

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

Ställer in automatisk svartnivåkalibrering (BLC) på kameran.

enable skicka True eller False för att slå på eller av BLC. Du vill vanligtvis alltid ha detta på.

regs om inaktiverat kan du manuellt ställa in BLC-registervärdena från ett tidigare anrop till CSI.blc_regs.

blc_regs() → List[int]#: Returnerar sensorns BLC-register som en lista med heltal. För användning med CSI.auto_blc.

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

Slår på (True) eller av (False) horisontellt speglingsläge. Standard är av.

Returnerar den aktuella inställningen om den anropas utan argument.

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

Slår på (True) eller av (False) vertikalt vändningsläge. Standard är av.

Returnerar den aktuella inställningen om den anropas utan argument.

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

Slår på (True) eller av (False) transponeringsläge. Standard är av.

vflip=False, hmirror=False, transpose=False -> 0 graders rotation
vflip=True, hmirror=False, transpose=True -> 90 graders rotation
vflip=True, hmirror=True, transpose=False -> 180 graders rotation
vflip=False, hmirror=True, transpose=True -> 270 graders rotation

Returnerar den aktuella inställningen om den anropas utan argument.

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

Slår på (True) eller av (False) automatiskt rotationsläge. Standard är av.

Returnerar den aktuella inställningen om den anropas utan argument.

Observera

Denna metod fungerar endast när OpenMV Cam har en imu installerad och aktiveras automatiskt.

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

Ställer in antalet bildbuffertar som används för att ta emot bilddata. Som standard försöker OpenMV Cam allokera det maximala antalet bildbuffertar den kan. Omallokering sker när CSI.pixformat, CSI.framesize eller CSI.window anropas.

count på 1 (enkelbuffert), 2 (dubbelbuffert) eller 3 (trippelbuffert) väljer motsvarande infångningsläge. Skicka 4 eller högre för att sätta drivrutinen i video-FIFO-läge där count buffertar köas — användbart för videoinspelning till ett SD-kort. Vid förlorad bildruta rensas alla bildbuffertar utom den aktiva, så att CSI.snapshot alltid returnerar en aktuell bildruta.

Returnerar det aktuella antalet om den anropas utan argument.

special_effect(effect: int) → bool#

Ställer in den speciella digitala effekten (en av csi.NORMAL eller csi.NEGATIVE).

Returnerar True vid framgång och False vid misslyckande.

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

enable True för att aktivera, False för att inaktivera. radi heltalsradie i pixlar att korrigera. coef korrigeringens styrka.

Returnerar True vid framgång och False vid misslyckande.

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

Registrerar återanropet cb att exekveras (i avbrottskontext) varje gång kameramodulen genererar en ny bildruta (men innan bildrutan tas emot).

cb tar ett argument och får det aktuella tillståndet för vsync-stiftet efter ändringen.

Returnerar det registrerade återanropet om den anropas utan argument. Skicka något icke-anropbart för att rensa återanropet.

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

Registrerar återanropet cb att exekveras (i avbrottskontext) varje gång kameramodulen genererar en ny bildruta och bildrutan är redo att läsas via CSI.snapshot.

cb tar inga argument. Använd detta för att schemalägga läsning av en bildruta senare med micropython.schedule().

Returnerar det registrerade återanropet om den anropas utan argument. Skicka något icke-anropbart för att rensa återanropet.

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

Exekverar en sensorspecifik begäran. request är en av IOCTL_*-konstanterna; de återstående positionsargumenten och returvärdet beror på begäran. De begäranden som stöds är grupperade efter sensorfamilj nedan.

Generiskt (valfri sensor):

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

ioctl(IOCTL_SET_READOUT_WINDOW, (w, h))

Ställer in sensorns avläsningsfönster. Ett mindre fönster höjer bildfrekvensen på bekostnad av synfältet.

ioctl(IOCTL_GET_READOUT_WINDOW)

Returnerar det aktuella avläsningsfönstret som en (x, y, w, h)-tupel.

ioctl(IOCTL_SET_TRIGGERED_MODE, enable)

Aktiverar (True) eller inaktiverar (False) utlöst läge på MT9V034.

ioctl(IOCTL_GET_TRIGGERED_MODE)

Returnerar det aktuella utlösta lägets tillstånd som en bool.

ioctl(IOCTL_SET_FOV_WIDE, enable)

När True instrueras framesize() att optimera för synfält snarare än bildfrekvens.

ioctl(IOCTL_GET_FOV_WIDE)

Returnerar det aktuella FOV-wide-tillståndet som en bool.

ioctl(IOCTL_SET_NIGHT_MODE, enable)

Aktiverar (True) eller inaktiverar (False) sensorns svagljus-”nattläge”. Endast OV7725 och OV5640.

ioctl(IOCTL_GET_NIGHT_MODE)

Returnerar det aktuella nattlägets tillstånd som en bool.

ioctl(IOCTL_GET_RGB_STATS)

Returnerar en 4-tupel med rå RGB-kanalstatistik (r, gb, gr, b) avläst från sensorn (används vanligtvis för vitbalansjustering).

OV5640 FPC – autofokus:

ioctl(IOCTL_TRIGGER_AUTO_FOCUS)

Startar en autofokussvepning på OV5640 FPC-modulen.

ioctl(IOCTL_PAUSE_AUTO_FOCUS)

Pausar en pågående autofokussvepning.

ioctl(IOCTL_RESET_AUTO_FOCUS)

Återställer autofokuspositionen till standardvärdet.

ioctl(IOCTL_WAIT_ON_AUTO_FOCUS)

ioctl(IOCTL_WAIT_ON_AUTO_FOCUS, timeout_ms)

Blockerar tills den aktuella autofokussvepningen är klar. timeout_ms är som standard 5000 om det utelämnas.

FLIR Lepton:

ioctl(IOCTL_LEPTON_GET_WIDTH)

Returnerar Lepton-bildens bredd i pixlar.

ioctl(IOCTL_LEPTON_GET_HEIGHT)

Returnerar Lepton-bildens höjd i pixlar.

ioctl(IOCTL_LEPTON_GET_RADIOMETRY)

Returnerar Leptons typ (radiometrisk eller inte) som ett heltal.

ioctl(IOCTL_LEPTON_GET_REFRESH)

Returnerar Leptons uppdateringsfrekvens i Hz.

ioctl(IOCTL_LEPTON_GET_RESOLUTION)

Returnerar Leptons ADC-upplösning i bitar.

ioctl(IOCTL_LEPTON_RUN_COMMAND, cmd)

Kör ett FLIR Lepton SDK-kommando. cmd är det 16-bitars kommando-id som definieras av SDK:n.

ioctl(IOCTL_LEPTON_SET_ATTRIBUTE, attr_id, payload)

Skriver ett Lepton SDK-attribut. attr_id är det 16-bitars attribut-id:t; payload är en bytes/bytearray vars längd måste vara en multipel av 16 bitar.

ioctl(IOCTL_LEPTON_GET_ATTRIBUTE, attr_id, words)

Läser ett Lepton SDK-attribut. attr_id är det 16-bitars attribut-id:t; words är antalet 16-bitars ord att läsa. Returnerar en bytearray.

ioctl(IOCTL_LEPTON_GET_FPA_TEMP)

Returnerar Leptons fokalplansmatristemperatur i grader Celsius.

ioctl(IOCTL_LEPTON_GET_AUX_TEMP)

Returnerar Leptons hjälptemperatur i grader Celsius.

ioctl(IOCTL_LEPTON_SET_MODE, measurement_enabled)

ioctl(IOCTL_LEPTON_SET_MODE, measurement_enabled, high_temp_enabled)

Växlar Lepton mellan AGC och direkt temperaturutdata. measurement_enabled=True aktiverar direkt temperaturutdata. Den valfria flaggan high_temp_enabled väljer högtemperaturområdet.

ioctl(IOCTL_LEPTON_GET_MODE)

Returnerar en 2-tupel (measurement_enabled, high_temp_enabled).

ioctl(IOCTL_LEPTON_SET_RANGE, (min_celsius, max_celsius))

Ställer in temperaturområdet som mappas till 0..255 när mätläge är aktiverat.

ioctl(IOCTL_LEPTON_GET_RANGE)

Returnerar det aktuella (min_celsius, max_celsius)-området.

Himax HM01B0 – rörelsedetektering:

ioctl(IOCTL_HIMAX_MD_ENABLE, enable)

Aktiverar (True) eller inaktiverar (False) HM01B0:s rörelsedetekteringsblock på sensorn.

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

ioctl(IOCTL_HIMAX_MD_WINDOW, (w, h))

Ställer in rörelsedetekteringsfönstret på HM01B0.

ioctl(IOCTL_HIMAX_MD_THRESHOLD, threshold)

Ställer in tröskelvärdet för rörelsedetektering (0 – 255).

ioctl(IOCTL_HIMAX_MD_CLEAR)

Rensar avbrottslåset för rörelsedetektering.

ioctl(IOCTL_HIMAX_OSC_ENABLE, enable)

Aktiverar (True) eller inaktiverar (False) HM01B0:s interna oscillator.

Prophesee GENX320 – händelsesensor:

ioctl(IOCTL_GENX320_SET_BIASES, preset)

Tillämpar en biasförinställning. preset är en av GENX320_BIASES_*-konstanterna.

ioctl(IOCTL_GENX320_SET_BIAS, bias, value)

Ställer in en enda bias. bias är en av GENX320_BIAS_*-konstanterna; value är heltalsinställningen.

ioctl(IOCTL_GENX320_SET_AFK, enable)

ioctl(IOCTL_GENX320_SET_AFK, enable, freq_low_hz, freq_high_hz)

Konfigurerar antiflimmerfiltret. enable är en bool; de valfria frekvensargumenten ställer in filtrets passband.

ioctl(IOCTL_GENX320_SET_STC, mode)

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

Konfigurerar det spatiotemporala kontrastfiltret. mode är en av GENX320_STC_*-konstanterna; upp till två ytterligare argument är lägesspecifika.

ioctl(IOCTL_GENX320_SET_MODE, mode)

ioctl(IOCTL_GENX320_SET_MODE, mode, evt_res)

Växlar sensorn mellan bild- och händelseläge. mode är en av GENX320_MODE_*-konstanterna. För händelseläge är evt_res radaxelns längd på händelsebufferten som skickas till IOCTL_GENX320_READ_EVENTS.

ioctl(IOCTL_GENX320_READ_EVENTS, buf)

Läser händelser till buf, en uint16 ndarray med formen (EVT_res, 6) där EVT_res är en tvåpotens mellan 1024 och 65536. Kolumnerna är:

[0] – händelsetyp (PIX_OFF_EVENT / PIX_ON_EVENT / utlösare).
[1] – sekunder.
[2] – millisekunder.
[3] – mikrosekunder.
[4] – x-koordinat.
[5] – y-koordinat.

Returnerar antalet skrivna händelser.

ioctl(IOCTL_GENX320_READ_EVENTS_RAW)

Returnerar en image.Image som innehåller den råa händelsebildrutan från GENX320.

ioctl(IOCTL_GENX320_CALIBRATE, iterations, sigma)

Stänger av pixlar vars brus är mer än sigma standardavvikelser från normalfördelningen. iterations är heltalsantalet kalibreringspass. Returnerar antalet inaktiverade pixlar.

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

Ställer in färgpaletten som ska användas för saker som FLIR Lepton-konvertering från gråskala till RGB565 eller GENX320-händelsevisualisering. En av image.PALETTE_RAINBOW, image.PALETTE_IRONBOW och (när det stöds) image.PALETTE_DEPTH, image.PALETTE_EVT_DARK eller image.PALETTE_EVT_LIGHT.

Returnerar den aktuella inställningen om den anropas utan argument.

__write_reg(address: int, value: int) → None#: Skriver value till kameraregistret på address.

Observera
Se kamerans datablad för registerinformation.

__read_reg(address: int) → int#: Läser kameraregistret på address.

Observera
Se kamerans datablad för registerinformation.

Funktioner#

csi.devices() → List[int]#: Returnerar en lista med de detekterade sensorchip-ID:na.

Konstanter#

csi.BINARY: int#: BINARY-pixelformat (bitmapp). Varje pixel är 1-bitars. Användbart för masklagring; kan användas med image.Image().

csi.GRAYSCALE: int#: GRAYSCALE-pixelformat (Y från YUV422). Varje pixel är 8-bitars.

csi.RGB565: int#: RGB565-pixelformat. Varje pixel är 16-bitars (5-bitars rött, 6-bitars grönt, 5-bitars blått).

csi.BAYER: int#: RAW BAYER-bildpixelformat.

csi.YUV422: int#: YUV422-pixelformat. Varje pixel lagras som ett 8-bitars Y-värde i gråskala följt av växlande 8-bitars U/V-färgvärden delade mellan två Y-värden (Y1, U, Y2, V, …). Endast vissa bildbehandlingsmetoder fungerar med YUV422.

csi.JPEG: int#: JPEG-läge. Kameramodulen matar ut komprimerade JPEG-bilder. Använd CSI.quality för att styra JPEG-kvaliteten. Fungerar endast för OV2640/OV5640-kamerorna.

csi.OV2640: int#: CSI.cid returnerar detta för OV2640-kameran.

csi.OV5640: int#: CSI.cid returnerar detta för OV5640-kameran.

csi.OV7670: int#: CSI.cid returnerar detta för OV7670-kameran.

csi.OV7690: int#: CSI.cid returnerar detta för OV7690-kameran.

csi.OV7725: int#: CSI.cid returnerar detta för OV7725-kameran.

csi.OV9650: int#: CSI.cid returnerar detta för OV9650-kameran.

csi.MT9V022: int#: CSI.cid returnerar detta för MT9V022-kameran.

csi.MT9V024: int#: CSI.cid returnerar detta för MT9V024-kameran.

csi.MT9V032: int#: CSI.cid returnerar detta för MT9V032-kameran.

csi.MT9V034: int#: CSI.cid returnerar detta för MT9V034-kameran.

csi.MT9M114: int#: CSI.cid returnerar detta för MT9M114-kameran.

csi.BOSON320: int#: CSI.cid returnerar detta för BOSON 320x256-kameran.

csi.BOSON640: int#: CSI.cid returnerar detta för BOSON 640x512-kameran.

csi.LEPTON: int#: CSI.cid returnerar detta för LEPTON1/2/3-kamerorna.

csi.HM01B0: int#: CSI.cid returnerar detta för HM01B0-kameran.

csi.HM0360: int#: CSI.cid returnerar detta för HM0360-kameran.

csi.GC2145: int#: CSI.cid returnerar detta för GC2145-kameran.

csi.GENX320ES: int#: CSI.cid returnerar detta för GENX320-kameran (teknisk provexemplar).

csi.GENX320: int#: CSI.cid returnerar detta för GENX320-kameran.

csi.PAG7920: int#: CSI.cid returnerar detta för PAG7920-kameran.

csi.PAG7936: int#: CSI.cid returnerar detta för PAG7936-kameran.

csi.PAJ6100: int#: CSI.cid returnerar detta för PAJ6100-kameran.

csi.FROGEYE2020: int#: CSI.cid returnerar detta för FROGEYE2020-kameran.

csi.SOFTCSI: int#: CSI.cid returnerar detta för programvaru-CSI-kameran.

csi.NORMAL: int#: Normalläge för CSI.special_effect.

csi.NEGATIVE: int#: Negativt läge för CSI.special_effect.

csi.QCIF: int#: 176x144-upplösning för kamerasensorn.

csi.CIF: int#: 352x288-upplösning för kamerasensorn.

csi.QSIF: int#: 176x120-upplösning för kamerasensorn.

csi.SIF: int#: 352x240-upplösning för kamerasensorn.

csi.QQQVGA: int#: 80x60-upplösning för kamerasensorn.

csi.QQVGA: int#: 160x120-upplösning för kamerasensorn.

csi.QVGA: int#: 320x240-upplösning för kamerasensorn.

csi.VGA: int#: 640x480-upplösning för kamerasensorn.

csi.HQVGA: int#: 240x160-upplösning för kamerasensorn.

csi.HVGA: int#: 480x320-upplösning för kamerasensorn.

csi.WVGA: int#: 720x480-upplösning för MT9V034-kamerasensorn.

csi.WVGA2: int#: 752x480-upplösning för MT9V034-kamerasensorn.

csi.SVGA: int#: 800x600-upplösning för kamerasensorn.

csi.XGA: int#: 1024x768-upplösning för kamerasensorn.

csi.WXGA: int#: 1280x768-upplösning för MT9M114-kamerasensorn.

csi.SXGA: int#: 1280x1024-upplösning för kamerasensorn. Fungerar endast för OV2640/OV5640-kamerorna.

csi.SXGAM: int#: 1280x960-upplösning för MT9M114-kamerasensorn.

csi.UXGA: int#: 1600x1200-upplösning för kamerasensorn. Fungerar endast för OV2640/OV5640-kamerorna.

csi.HD: int#: 1280x720-upplösning för kamerasensorn.

csi.FHD: int#: 1920x1080-upplösning för kamerasensorn. Fungerar endast för OV5640-kameran.

csi.QHD: int#: 2560x1440-upplösning för kamerasensorn. Fungerar endast för OV5640-kameran.

csi.QXGA: int#: 2048x1536-upplösning för kamerasensorn. Fungerar endast för OV5640-kameran.

csi.WQXGA: int#: 2560x1600-upplösning för kamerasensorn. Fungerar endast för OV5640-kameran.

csi.WQXGA2: int#: 2592x1944-upplösning för kamerasensorn. Fungerar endast för OV5640-kameran.

csi.IOCTL_SET_READOUT_WINDOW: int#: Ställer in avläsningsfönstret. Se CSI.ioctl.

csi.IOCTL_GET_READOUT_WINDOW: int#: Hämtar avläsningsfönstret. Se CSI.ioctl.

csi.IOCTL_SET_TRIGGERED_MODE: int#: Ställer in utlöst läge för MT9V034. Se CSI.ioctl.

csi.IOCTL_GET_TRIGGERED_MODE: int#: Hämtar tillståndet för utlöst läge för MT9V034. Se CSI.ioctl.

csi.IOCTL_SET_FOV_WIDE: int#: Aktiverar CSI.framesize att optimera för synfält framför FPS. Se CSI.ioctl.

csi.IOCTL_GET_FOV_WIDE: int#: Returnerar om CSI.framesize optimerar för synfält framför FPS. Se CSI.ioctl.

csi.IOCTL_TRIGGER_AUTO_FOCUS: int#: Utlöser autofokus på OV5640 FPC-kameramodulen. Se CSI.ioctl.

csi.IOCTL_PAUSE_AUTO_FOCUS: int#: Pausar autofokus (medan det körs) för OV5640 FPC-kameramodulen. Se CSI.ioctl.

csi.IOCTL_RESET_AUTO_FOCUS: int#: Återställer autofokus till standard för OV5640 FPC-kameramodulen. Se CSI.ioctl.

csi.IOCTL_WAIT_ON_AUTO_FOCUS: int#: Väntar på att autofokus ska bli klart på OV5640 FPC-kameramodulen. Se CSI.ioctl.

csi.IOCTL_SET_NIGHT_MODE: int#: Slår på eller av nattläge. Minskar bildfrekvensen för att öka exponeringen dynamiskt. Se CSI.ioctl.

csi.IOCTL_GET_NIGHT_MODE: int#: Returnerar om nattläge är aktiverat. Se CSI.ioctl.

csi.IOCTL_LEPTON_GET_WIDTH: int#: Returnerar FLIR Lepton-bildens upplösningsbredd i pixlar. Se CSI.ioctl.

csi.IOCTL_LEPTON_GET_HEIGHT: int#: Returnerar FLIR Lepton-bildens upplösningshöjd i pixlar. Se CSI.ioctl.

csi.IOCTL_LEPTON_GET_RADIOMETRY: int#: Returnerar FLIR Lepton-typen (radiometrisk eller inte). Se CSI.ioctl.

csi.IOCTL_LEPTON_GET_REFRESH: int#: Returnerar FLIR Lepton-uppdateringsfrekvensen i Hz. Se CSI.ioctl.

csi.IOCTL_LEPTON_GET_RESOLUTION: int#: Returnerar FLIR Lepton-ADC-upplösningen i bitar. Se CSI.ioctl.

csi.IOCTL_LEPTON_RUN_COMMAND: int#: Exekverar ett 16-bitars kommando från FLIR Lepton SDK. Se CSI.ioctl.

csi.IOCTL_LEPTON_SET_ATTRIBUTE: int#: Ställer in ett FLIR Lepton-attribut från FLIR Lepton SDK. Se CSI.ioctl.

csi.IOCTL_LEPTON_GET_ATTRIBUTE: int#: Hämtar ett FLIR Lepton-attribut från FLIR Lepton SDK. Se CSI.ioctl.

csi.IOCTL_LEPTON_GET_FPA_TEMP: int#: Hämtar FLIR Lepton FPA-temperaturen i Celsius. Se CSI.ioctl.

csi.IOCTL_LEPTON_GET_AUX_TEMP: int#: Hämtar FLIR Lepton AUX-temperaturen i Celsius. Se CSI.ioctl.

csi.IOCTL_LEPTON_SET_MODE: int#: Sätter FLIR Lepton-drivrutinen i ett läge där varje pixel är ett temperaturvärde. Se CSI.ioctl.

csi.IOCTL_LEPTON_GET_MODE: int#: Returnerar om mätläge är aktiverat för FLIR Lepton-sensorn. Se CSI.ioctl.

csi.IOCTL_LEPTON_SET_RANGE: int#: Ställer in temperaturområdet som mappas till pixelvärden i mätläge. Se CSI.ioctl.

csi.IOCTL_LEPTON_GET_RANGE: int#: Returnerar temperaturområdet som används för mätläge. Se CSI.ioctl.

csi.IOCTL_HIMAX_MD_ENABLE: int#: Styr avbrottet för rörelsedetektering på HM01B0. Se CSI.ioctl.

csi.IOCTL_HIMAX_MD_WINDOW: int#: Ställer in rörelsedetekteringsfönstret på HM01B0. Se CSI.ioctl.

csi.IOCTL_HIMAX_MD_THRESHOLD: int#: Ställer in tröskelvärdet för rörelsedetektering på HM01B0. Se CSI.ioctl.

csi.IOCTL_HIMAX_MD_CLEAR: int#: Rensar avbrottet för rörelsedetektering på HM01B0. Se CSI.ioctl.

csi.IOCTL_HIMAX_OSC_ENABLE: int#: Styr den interna oscillatorn på HM01B0. Se CSI.ioctl.

csi.IOCTL_GET_RGB_STATS: int#: Returnerar RGB-statistiken från kamerasensorn. Se CSI.ioctl.

csi.IOCTL_GENX320_SET_BIASES: int#: Ställer in GENX320-sensorns biaser till en av GENX320_BIASES_*-förinställningarna. Se CSI.ioctl. Efter CSI.reset tillämpar drivrutinen csi.GENX320_BIASES_LOW_NOISE, inte csi.GENX320_BIASES_DEFAULT — använd denna ioctl för att växla till en annan förinställning när applikationen behöver mer känslighet eller bandbredd.

csi.GENX320_BIASES_DEFAULT: int#: GenX320-databladets standardvärden — balanserad känslighet, brus och bandbredd för allmänna scener.

csi.GENX320_BIASES_LOW_LIGHT: int#: Avstämd för svagljusförhållanden — båda kontrasttröskelvärdena lösgjorda för högre känslighet, FO sänkt, HPF inaktiverat så att långsamma ljusstyrkeförändringar fortfarande registreras.

csi.GENX320_BIASES_ACTIVE_MARKER: int#: Avstämd för att spåra blinkande LED:er med hög kontrast (aktiva markörer) — kontrasttröskelvärdena höjda så att endast skarpa övergångar utlöser, FO och HPF uppvridna högt för att maximera bandbredd och avvisa långsam omgivningsdrift, REFR=0 så att varje blinkflank fångas.

csi.GENX320_BIASES_LOW_NOISE: int#: Drivrutinsstandard — lägre känslighet än DEFAULT (höjda kontrasttröskelvärden) och ett lägre FO för mindre bakgrundsbrusaktivitet. Bäst för statiska eller långsamma scener där falska händelser annars skulle dominera.

csi.GENX320_BIASES_HIGH_SPEED: int#: Avstämd för scener med snabb rörelse — högre FO för bredare pixelbandbredd, högre HPF för att avvisa långsamma förändringar, högre REFR för en längre dötid efter varje händelse så att avläsningen inte mättas.

csi.IOCTL_GENX320_SET_BIAS: int#: Ställer in en enda GENX320-sensorbias till ett DAC-värde. Skicka en GENX320_BIAS_*-konstant (csi.GENX320_BIAS_DIFF_OFF, csi.GENX320_BIAS_DIFF_ON, csi.GENX320_BIAS_FO, csi.GENX320_BIAS_HPF eller csi.GENX320_BIAS_REFR) och ett DAC-heltalsvärde. Varje bias är oberoende — anropa denna ioctl upprepade gånger för att justera endast de biaser du behöver efter att ha tillämpat en förinställning. Se CSI.ioctl.

csi.GENX320_BIAS_DIFF_OFF: int#: Negativt komparatorkontrasttröskelvärde — styr hur mycket en pixel måste mörkna innan en csi.PIX_OFF_EVENT utlöses. Lägre värde = känsligare (fler händelser).

csi.GENX320_BIAS_DIFF_ON: int#: Positivt komparatorkontrasttröskelvärde — styr hur mycket en pixel måste ljusna innan en csi.PIX_ON_EVENT utlöses. Lägre värde = känsligare (fler händelser).

csi.GENX320_BIAS_FO: int#: Pixelns lågpassgränsfrekvens — avväger pixelbandbredd (hastighet/latens) mot bakgrundsbrusaktivitet. Högre värde = snabbare pixelrespons, mer brus.

csi.GENX320_BIAS_HPF: int#: Pixelns högpassgränsfrekvens — avvisar långsamma ljusstyrkeförändringar. Högre värde = långsammare förändringar bortfiltrerade (endast snabba övergångar registreras).

csi.GENX320_BIAS_REFR: int#: Pixelns refraktärperiod — dötid efter att en pixel sänt en händelse under vilken den inte kan utlösa igen. Högre värde = längre dötid, färre händelser från en upptagen pixel.

csi.IOCTL_GENX320_SET_AFK: int#: Ställer in GENX320:s antiflimmerfilter (AFK), som avvisar händelser från pixlar som växlar i ett periodiskt frekvensband (lysrörsbelysning, LED-drivna skärmar osv.). Skicka enable (1 för att aktivera, 0 för att inaktivera) och, vid aktivering, bandkanterna i hertz: (enable, freq_low_hz, freq_high_hz). Se CSI.ioctl.

csi.IOCTL_GENX320_SET_STC: int#: Ställer in GENX320:s spatiotemporala kontrastfilterläge (STC). Skicka en GENX320_STC_*-konstant (csi.GENX320_STC_DISABLE, csi.GENX320_STC_ONLY, csi.GENX320_STC_TRAIL_ONLY, csi.GENX320_STC_TRAIL) följt av det eller de tröskelvärden som läget kräver (i millisekunder). Se CSI.ioctl.

csi.GENX320_STC_DISABLE: int#: Inaktiverar GENX320 STC/trail-filtret — varje händelse släpps igenom.

csi.GENX320_STC_ONLY: int#: Behåller den andra händelsen i en skur; kastar den första händelsen och alla senare händelser. Tar en parameter, stc_threshold i millisekunder — händelser inom det fönstret från en tidigare händelse på samma pixel anses tillhöra samma skur.

csi.GENX320_STC_TRAIL_ONLY: int#: Behåller den första händelsen i en skur; kastar efterföljande händelser på samma pixel tills trail_threshold har förflutit. Tar en parameter, trail_threshold i millisekunder.

csi.GENX320_STC_TRAIL: int#: Behåller den första händelsen i en skur plus efterföljande flanker — kombinerar csi.GENX320_STC_ONLY och csi.GENX320_STC_TRAIL_ONLY. Tar två parametrar, stc_threshold och trail_threshold (båda ms); sensorn kräver att de två håller sig inom ungefär ett 13:1-förhållande.

csi.IOCTL_GENX320_SET_MODE: int#: Ställer in GENX320:s driftläge. Skicka csi.GENX320_MODE_HISTO för händelsehistogrammet på chipet (kameran beter sig som en vanlig gråskalekamera vid den konfigurerade bildfrekvensen) eller csi.GENX320_MODE_EVENT följt av radaxelns längd på händelse-ndarray (en tvåpotens mellan 1024 och 65536) för rå händelseströmning. Se CSI.ioctl.

csi.GENX320_MODE_HISTO: int#: Histogramläge — händelser ackumuleras på chipet i fack per pixel och rapporteras som en 320x320 gråskalebildruta vid den konfigurerade frekvensen (~20-350 FPS). Kameran ser ut som en vanlig kamera, så alla standardrutiner för bildbehandling fungerar direkt.

csi.GENX320_MODE_EVENT: int#: Händelseläge — förbigår histogrammet på chipet och strömmar råa händelser till en numpy-ndarray med mikrosekundstidsstämplar, för applikationer som behöver fullständig tidsmässig detalj snarare än en förgrupperad bildruta.

csi.IOCTL_GENX320_READ_EVENTS: int#: Läser råa händelser till en uint16-ndarray med formen (EVT_res, 6) (med EVT_res matchande buffertstorleken som skickats till csi.IOCTL_GENX320_SET_MODE). Kolumnerna är [0] händelsetyp (csi.PIX_OFF_EVENT, csi.PIX_ON_EVENT, csi.EXT_TRIGGER_RISING/FALLING, csi.RST_TRIGGER_RISING/FALLING), [1] sekundtidsstämpel, [2] millisekunder, [3] mikrosekunder, [4] X-koordinat (0-319), [5] Y-koordinat (0-319). Returnerar antalet händelser som skrivits till bufferten och lämnar äldre rader bortom det antalet orörda. Se CSI.ioctl.

csi.IOCTL_GENX320_CALIBRATE: int#: Inaktiverar automatiskt heta pixlar — pixlar som utlöser falskt även på en statisk scen. Drivrutinen bygger en 320x320 träffräknare per pixel, beräknar medelvärdet och standardavvikelsen och inaktiverar alla pixlar vars antal överstiger mean + sigma * stddev. Skicka en händelsebudget (händelser att räkna innan statistiken beräknas — högre = pålitligare uppskattning, långsammare; ~10000 är ett bra standardvärde) och ett sigma-flyttal (lägre = mer aggressivt, ~0,5 standard). Returnerar antalet inaktiverade pixlar. Rikta kameran mot en statisk scen först så att rörelsedrivna händelser inte räknas mot pixlar som faktiskt fungerar bra. Se CSI.ioctl.

csi.IOCTL_GENX320_READ_EVENTS_RAW: int#: Returnerar en rå händelsebildruta image.Image från GENX320, med händelserna fortfarande i chipets ursprungliga packade kodning — användbart om du vill vidarebefordra den råa strömmen till en PC för avkodning offline snarare än att bearbeta den på kameran. Se CSI.ioctl.

csi.PIX_OFF_EVENT: int#: GENX320-händelsetyp (kolumn [0]) — en pixel detekterade en minskning av ljusstyrka (det negativa kontrasttröskelvärdet korsades). Kolumnerna [4]/[5] bär pixelns X/Y.

csi.PIX_ON_EVENT: int#: GENX320-händelsetyp (kolumn [0]) — en pixel detekterade en ökning av ljusstyrka (det positiva kontrasttröskelvärdet korsades). Kolumnerna [4]/[5] bär pixelns X/Y.

csi.RST_TRIGGER_RISING: int#: GENX320-händelsetyp (kolumn [0]) — pixelåterställningsutlösare, stigande flank. X/Y används inte. Genereras inte av den fasta programvaran för närvarande.

csi.RST_TRIGGER_FALLING: int#: GENX320-händelsetyp (kolumn [0]) — pixelåterställningsutlösare, fallande flank. X/Y används inte. Genereras inte av den fasta programvaran för närvarande.

csi.EXT_TRIGGER_RISING: int#: GENX320-händelsetyp (kolumn [0]) — sensorns externa utlösarstift såg en stigande flank. GENX320:s externa utlösaringång är kopplad till kamerans bildsynkroniseringslinje, som även är dragen till P10 på processorn och stiftlisten. X/Y används inte.

csi.EXT_TRIGGER_FALLING: int#: GENX320-händelsetyp (kolumn [0]) — sensorns externa utlösarstift såg en fallande flank. GENX320:s externa utlösaringång är kopplad till kamerans bildsynkroniseringslinje, som även är dragen till P10 på processorn och stiftlisten. X/Y används inte.

csi — kamerasensorer#

Användning med asyncio#

class CSI – Camera Sensor Interface#

Metoder#

Funktioner#

Konstanter#

`csi` — kamerasensorer#