`csi` — sensores de câmara#

O módulo csi é a interface moderna e orientada a objetos para o(s) sensor(es) de câmara numa OpenMV Cam. Cada sensor físico é representado por uma instância CSI, pelo que as placas de imageamento multiespectrais que combinam um sensor de cor com um sensor térmico ou de eventos podem controlar cada um de forma independente, passando um cid diferente ao construtor. As câmaras com um único sensor apenas instanciam um CSI.

Um objeto CSI gere toda a configuração do sensor – formato de pixel, tamanho de fotograma / janela, exposição / ganho / balanço de brancos, espelho e inversão por hardware, padrão de teste de barras de cor, relógio de taxa de fotogramas, ROI para auto-exposição e comandos ioctl específicos do chip. Os fotogramas são capturados com CSI.snapshot(), que devolve um image.Image apoiado pelo buffer de fotograma.

Este módulo substitui o módulo legado sensor (que expunha a mesma funcionalidade como funções ao nível do módulo associadas a um único sensor oculto). O novo código deverá usar CSI.

Exemplo de utilização:

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

Utilização com Asyncio#

O ciclo bloqueante CSI.snapshot() acima não coopera com o ciclo de eventos asyncio – enquanto snapshot aguarda pelo próximo fotograma, todas as outras corrotinas do programa ficam congeladas. Para permitir que um ciclo de captura coexista com outro trabalho concorrente (um cliente UART, um observador de botões, uma tarefa de rede), envolva CSI num pequeno adaptador que transforma snapshot numa corrotina compatível com await, sondando snapshot(blocking=False) e cedendo ao ciclo de eventos entre verificações:

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__ redireciona todos os outros atributos (reset, pixformat, framesize, os controlos do sensor) para o CSI subjacente, pelo que o adaptador é um substituto direto. A primeira chamada não bloqueante também inicia a captura DMA da câmara se ainda não estiver em execução, pelo que não é necessário qualquer arranque adicional.

Um ciclo de captura encaixa então num programa asyncio maior como mais uma corrotina:

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

A definição framebuffers ainda é relevante neste padrão – o modo de buffer único faz com que snapshot(blocking=False) devolva None até que o próximo fotograma seja capturado, enquanto o buffer duplo ou triplo suaviza isso para que o adaptador geralmente encontre um fotograma em buffer à espera na primeira sondagem. Consulte o exemplo AsyncCSI no tutorial de asyncio para o guia completo.

class CSI – Interface do Sensor de Câmara#

A classe CSI é utilizada para controlar um sensor de câmara.

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

Cria um objeto para comunicar com um sensor de câmara. Em placas com vários sensores, o objeto CSI em questão pode ser selecionado passando um cid como csi.LEPTON para selecionar um módulo sensor FLIR Lepton. Se cid for -1, o sensor primário é selecionado (tipicamente um módulo de câmara de cor em placas com vários sensores).

Se delays for False, todos os atrasos de tempo de estabilização no controlador csi são desativados. Por padrão, o controlador do sensor aguarda após reset / mudança de modo para evitar que fotogramas corrompidos sejam devolvidos por CSI.snapshot. Desativar os atrasos permite agrupar atualizações e aplicar um único atraso no final antes de chamar CSI.snapshot.

Se fflush for False, a descarga automática do buffer de fotograma mencionada em CSI.framebuffers é desativada. Isto remove qualquer limite de tempo nos fotogramas na fila FIFO do buffer de fotograma.

stream seleciona se este CSI é a fonte de stream enviada para o IDE. Se None (predefinição), o CSI torna-se a fonte de stream apenas se for o sensor primário (não auxiliar). Passe True para forçar este CSI a ser a fonte de stream, ou qualquer valor falso para deixar a fonte de stream existente inalterada.

Métodos#

reset(hard: bool = True) → None#: Inicializa o sensor de câmara. Efetua um reset por hardware alternando o GPIO do sinal RESET para o módulo de câmara se hard for True. hard deve ser definido como falso ao reiniciar sensores de câmara auxiliares que partilham o mesmo GPIO do sinal RESET que o módulo primário.

shutdown(enable: bool) → None#: Coloca a câmara num modo de menor consumo de energia do que o modo de suspensão (mas a câmara tem de ser reiniciada ao ser acordada).

sleep(enable: bool) → None#: Coloca a câmara em modo de suspensão se enable for True. Caso contrário, acorda-a novamente.

flush() → None#: Copia o conteúdo atual do buffer de fotograma para a pré-visualização do IDE. Chame este método após o último CSI.snapshot se o script terminar, para que o IDE mostre o último fotograma.

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

Tira uma fotografia usando a câmara e devolve um objeto image.Image.

Se time e/ou frames for passado, snapshot bloqueará durante esse número de milissegundos time e/ou frames capturados da câmara. Ambos os argumentos podem ser usados ao mesmo tempo. Após time e/ou frames ter decorrido, snapshot devolverá None.

blocking pode ser False para ativar o comportamento não bloqueante, que fará com que snapshot devolva None quando a próxima imagem da câmara não estiver pronta, em vez de aguardar.

image pode ser outro objeto image.Image para atualizar com a nova imagem capturada da câmara em vez de devolver um novo objeto image.Image. O conteúdo da imagem anterior é substituído por uma cópia profunda.

Se CSI.auto_rotation estiver ativada, este método devolverá um image.Image já rodado.

width() → int#: Devolve a largura de resolução do sensor.

height() → int#: Devolve a altura de resolução do sensor.

cid() → int#: Devolve o ID do chip do módulo de câmara. Compare com qualquer um de 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 ou csi.SOFTCSI.

readable() → bool#: Devolve True se houver uma imagem pronta a ser devolvida por CSI.snapshot, pelo que uma chamada a snapshot não bloqueará.

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

Define o formato de pixel do módulo de câmara para um de csi.GRAYSCALE, csi.RGB565, csi.BAYER, csi.YUV422 ou csi.JPEG (apenas no OV2640/OV5640).

Devolve o pixformat atual se chamado sem argumentos.

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

Define o tamanho de fotograma do módulo de câmara para uma das constantes de tamanho (ex.: csi.QVGA, csi.VGA, csi.HD, etc. — consulte a secção de constantes).

Em alternativa, pode passar um tamanho de fotograma personalizado como um tuplo (w, h). Quando CSI.snapshot é chamado, o tamanho de fotograma personalizado será avaliado de acordo com as regras DMA. Geralmente, os tamanhos de fotograma têm de ser múltiplos de 8 pixels e/ou 16 bytes.

Devolve o tamanho de fotograma atual se chamado sem argumentos.

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

Define a taxa de fotogramas em Hz para o módulo de câmara.

Devolve a taxa de fotogramas atual se chamado sem argumentos.

Nota

CSI.framerate funciona descartando fotogramas recebidos pelo módulo de câmara para manter a taxa de fotogramas igual ou inferior à taxa especificada. Por padrão, a câmara funcionará à taxa de fotogramas máxima. Se implementado para o sensor de câmara em questão, CSI.framerate também reduzirá internamente a taxa de fotogramas do sensor de câmara para poupar energia e melhorar a qualidade de imagem ao aumentar a exposição do sensor. CSI.framerate pode entrar em conflito com CSI.auto_exposure em algumas câmaras.

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

Define a resolução da câmara para uma sub-região da resolução atual. roi é um tuplo (x, y, w, h). Também pode passar (w, h) e a janela será centrada.

Devolve o tuplo (x, y, w, h) atual se chamado sem argumentos.

gainceiling(gainceiling: int) → bool#

Define o teto de ganho de imagem da câmara para um de 2, 4, 8, 16, 32, 64 ou 128.

Devolve True em caso de sucesso e False em caso de falha.

brightness(brightness: int) → bool#

Define o brilho da imagem da câmara.

Devolve True em caso de sucesso e False em caso de falha.

contrast(contrast: int) → bool#

Define o contraste da imagem da câmara.

Devolve True em caso de sucesso e False em caso de falha.

saturation(saturation: int) → bool#

Define a saturação da imagem da câmara.

Devolve True em caso de sucesso e False em caso de falha.

quality(quality: int) → bool#

Define a qualidade de compressão JPEG da imagem da câmara. 0 - 100.

Devolve True em caso de sucesso e False em caso de falha.

Nota

Apenas para as câmaras OV2640/OV5640.

colorbar(enable: bool) → bool#

Liga (True) ou desliga (False) o modo de barras de cor. Por padrão está desligado.

Devolve True em caso de sucesso e False em caso de falha.

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

enable liga (True) ou desliga (False) o controlo automático de ganho. A câmara arranca com o controlo automático de ganho ligado.

Se enable for False, pode definir um ganho fixo em decibéis com gain_db.

Se enable for True, pode definir o teto máximo de ganho em decibéis com gain_db_ceiling para o algoritmo de controlo automático de ganho.

Nota

Também é necessário desligar o balanço de brancos se pretender rastrear cores.

gain_db() → float#: Devolve o valor atual de ganho da câmara em decibéis.

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

enable liga (True) ou desliga (False) o controlo automático de exposição. A câmara arranca com o controlo automático de exposição ligado.

Se enable for False, pode definir um tempo de exposição fixo em microssegundos com exposure_us.

Nota

Os algoritmos de auto-exposição da câmara são bastante conservadores no que respeita ao ajuste do valor de exposição e geralmente evitam alterá-lo significativamente. Em vez disso, ajustam bastante o valor de ganho para lidar com variações de iluminação.

exposure_us() → int#: Devolve o valor atual de exposição da câmara em microssegundos.

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

enable liga (True) ou desliga (False) o balanço de brancos automático. A câmara arranca com o balanço de brancos automático ligado.

Se enable for False, pode definir um ganho fixo em decibéis para os canais vermelho, verde e azul respetivamente com rgb_gain_db.

Nota

Também é necessário desligar o controlo de ganho se pretender rastrear cores.

rgb_gain_db() → Tuple[float, float, float]#: Devolve um tuplo (r, g, b) com os valores atuais de ganho dos canais vermelho, verde e azul da câmara em decibéis.

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

Configura a calibração automática do nível de preto (BLC) na câmara.

enable passe True ou False para ligar ou desligar a BLC. Normalmente é sempre conveniente ter esta opção ligada.

regs se desativada, pode definir manualmente os valores dos registos BLC a partir de uma chamada anterior a CSI.blc_regs.

blc_regs() → List[int]#: Devolve os registos BLC do sensor como uma lista de inteiros. Para uso com CSI.auto_blc.

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

Liga (True) ou desliga (False) o modo de espelho horizontal. Por padrão está desligado.

Devolve a definição atual se chamado sem argumentos.

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

Liga (True) ou desliga (False) o modo de inversão vertical. Por padrão está desligado.

Devolve a definição atual se chamado sem argumentos.

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

Liga (True) ou desliga (False) o modo de transposição. Por padrão está desligado.

vflip=False, hmirror=False, transpose=False -> rotação de 0 graus
vflip=True, hmirror=False, transpose=True -> rotação de 90 graus
vflip=True, hmirror=True, transpose=False -> rotação de 180 graus
vflip=False, hmirror=True, transpose=True -> rotação de 270 graus

Devolve a definição atual se chamado sem argumentos.

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

Liga (True) ou desliga (False) o modo de rotação automática. Por padrão está desligado.

Devolve a definição atual se chamado sem argumentos.

Nota

Este método só funciona quando a OpenMV Cam tem um imu instalado e está ativado automaticamente.

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

Define o número de buffers de fotograma utilizados para receber dados de imagem. Por padrão, a OpenMV Cam tentará alocar o número máximo de buffers de fotograma que conseguir. A reafetação ocorre sempre que CSI.pixformat, CSI.framesize ou CSI.window são chamados.

count de 1 (buffer único), 2 (buffer duplo) ou 3 (buffer triplo) seleciona o modo de captura correspondente. Passe 4 ou mais para colocar o controlador em modo FIFO de vídeo onde count buffers são enfileirados — útil para gravação de vídeo num cartão SD. Em caso de descarte de fotograma, todos os buffers de fotograma exceto o ativo são limpos, pelo que CSI.snapshot devolve sempre um fotograma recente.

Devolve o count atual se chamado sem argumentos.

special_effect(effect: int) → bool#

Define o efeito digital especial (um de csi.NORMAL ou csi.NEGATIVE).

Devolve True em caso de sucesso e False em caso de falha.

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

enable True para ativar, False para desativar. radi raio inteiro de pixels a corrigir. coef potência de correção.

Devolve True em caso de sucesso e False em caso de falha.

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

Regista o callback cb para ser executado (em contexto de interrupção) sempre que o módulo de câmara gerar um novo fotograma (mas antes de o fotograma ser recebido).

cb recebe um argumento e recebe o estado atual do pino vsync após a mudança.

Devolve o callback registado se chamado sem argumentos. Passe qualquer valor não chamável para limpar o callback.

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

Regista o callback cb para ser executado (em contexto de interrupção) sempre que o módulo de câmara gerar um novo fotograma e o fotograma estiver pronto para ser lido via CSI.snapshot.

cb não recebe argumentos. Use isto para agendar a leitura de um fotograma mais tarde com micropython.schedule().

Devolve o callback registado se chamado sem argumentos. Passe qualquer valor não chamável para limpar o callback.

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

Executa um pedido específico do sensor. request é uma das constantes IOCTL_*; os restantes argumentos posicionais e o valor de retorno dependem do pedido. Os pedidos suportados estão agrupados por família de sensor abaixo.

Genérico (qualquer sensor):

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

ioctl(IOCTL_SET_READOUT_WINDOW, (w, h))

Define a janela de leitura do sensor. Uma janela menor aumenta a taxa de fotogramas à custa do campo de visão.

ioctl(IOCTL_GET_READOUT_WINDOW)

Devolve a janela de leitura atual como um tuplo (x, y, w, h).

ioctl(IOCTL_SET_TRIGGERED_MODE, enable)

Ativa (True) ou desativa (False) o modo disparado no MT9V034.

ioctl(IOCTL_GET_TRIGGERED_MODE)

Devolve o estado atual do modo disparado como um bool.

ioctl(IOCTL_SET_FOV_WIDE, enable)

Quando True, instrui framesize() a otimizar para o campo de visão em vez da taxa de fotogramas.

ioctl(IOCTL_GET_FOV_WIDE)

Devolve o estado atual de FOV amplo como um bool.

ioctl(IOCTL_SET_NIGHT_MODE, enable)

Ativa (True) ou desativa (False) o «modo noturno» de baixa luminosidade do sensor. Apenas para OV7725 e OV5640.

ioctl(IOCTL_GET_NIGHT_MODE)

Devolve o estado atual do modo noturno como um bool.

ioctl(IOCTL_GET_RGB_STATS)

Devolve um tuplo de 4 elementos com as estatísticas brutas dos canais RGB (r, gb, gr, b) lidas do sensor (normalmente usadas para ajuste do balanço de brancos).

OV5640 FPC – focagem automática:

ioctl(IOCTL_TRIGGER_AUTO_FOCUS)

Inicia uma varredura de focagem automática no módulo OV5640 FPC.

ioctl(IOCTL_PAUSE_AUTO_FOCUS)

Pausa uma varredura de focagem automática em curso.

ioctl(IOCTL_RESET_AUTO_FOCUS)

Repõe a posição de focagem automática para o valor predefinido.

ioctl(IOCTL_WAIT_ON_AUTO_FOCUS)

ioctl(IOCTL_WAIT_ON_AUTO_FOCUS, timeout_ms)

Bloqueia até que a varredura de focagem automática atual termine. timeout_ms assume o valor predefinido de 5000 se omitido.

FLIR Lepton:

ioctl(IOCTL_LEPTON_GET_WIDTH)

Devolve a largura da imagem Lepton em pixels.

ioctl(IOCTL_LEPTON_GET_HEIGHT)

Devolve a altura da imagem Lepton em pixels.

ioctl(IOCTL_LEPTON_GET_RADIOMETRY)

Devolve o tipo do Lepton (radiométrico ou não) como um int.

ioctl(IOCTL_LEPTON_GET_REFRESH)

Devolve a taxa de atualização do Lepton em Hz.

ioctl(IOCTL_LEPTON_GET_RESOLUTION)

Devolve a resolução ADC do Lepton em bits.

ioctl(IOCTL_LEPTON_RUN_COMMAND, cmd)

Executa um comando do SDK FLIR Lepton. cmd é o id de comando de 16 bits definido pelo SDK.

ioctl(IOCTL_LEPTON_SET_ATTRIBUTE, attr_id, payload)

Escreve um atributo do SDK Lepton. attr_id é o id de atributo de 16 bits; payload é um bytes/bytearray cujo comprimento tem de ser múltiplo de 16 bits.

ioctl(IOCTL_LEPTON_GET_ATTRIBUTE, attr_id, words)

Lê um atributo do SDK Lepton. attr_id é o id de atributo de 16 bits; words é o número de palavras de 16 bits a ler. Devolve um bytearray.

ioctl(IOCTL_LEPTON_GET_FPA_TEMP)

Devolve a temperatura do array de plano focal do Lepton em graus Celsius.

ioctl(IOCTL_LEPTON_GET_AUX_TEMP)

Devolve a temperatura auxiliar do Lepton em graus Celsius.

ioctl(IOCTL_LEPTON_SET_MODE, measurement_enabled)

ioctl(IOCTL_LEPTON_SET_MODE, measurement_enabled, high_temp_enabled)

Alterna o Lepton entre AGC e saída de temperatura direta. measurement_enabled=True ativa a saída de temperatura direta. O sinalizador opcional high_temp_enabled seleciona o intervalo de alta temperatura.

ioctl(IOCTL_LEPTON_GET_MODE)

Devolve um tuplo de 2 elementos (measurement_enabled, high_temp_enabled).

ioctl(IOCTL_LEPTON_SET_RANGE, (min_celsius, max_celsius))

Define o intervalo de temperatura mapeado para 0..255 quando o modo de medição está ativado.

ioctl(IOCTL_LEPTON_GET_RANGE)

Devolve o intervalo (min_celsius, max_celsius) atual.

Himax HM01B0 – deteção de movimento:

ioctl(IOCTL_HIMAX_MD_ENABLE, enable)

Ativa (True) ou desativa (False) o bloco de deteção de movimento no próprio sensor do HM01B0.

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

ioctl(IOCTL_HIMAX_MD_WINDOW, (w, h))

Define a janela de deteção de movimento no HM01B0.

ioctl(IOCTL_HIMAX_MD_THRESHOLD, threshold)

Define o limiar de deteção de movimento (0 – 255).

ioctl(IOCTL_HIMAX_MD_CLEAR)

Limpa o latch de interrupção de deteção de movimento.

ioctl(IOCTL_HIMAX_OSC_ENABLE, enable)

Ativa (True) ou desativa (False) o oscilador interno do HM01B0.

Prophesee GENX320 – sensor de eventos:

ioctl(IOCTL_GENX320_SET_BIASES, preset)

Aplica um predefinido de polarização. preset é uma das constantes GENX320_BIASES_*.

ioctl(IOCTL_GENX320_SET_BIAS, bias, value)

Define uma única polarização. bias é uma das constantes GENX320_BIAS_*; value é a definição inteira.

ioctl(IOCTL_GENX320_SET_AFK, enable)

ioctl(IOCTL_GENX320_SET_AFK, enable, freq_low_hz, freq_high_hz)

Configura o filtro anti-cintilação. enable é um bool; os argumentos de frequência opcionais definem a banda de passagem do filtro.

ioctl(IOCTL_GENX320_SET_STC, mode)

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

Configura o filtro de contraste espácio-temporal. mode é uma das constantes GENX320_STC_*; até dois argumentos adicionais são específicos do modo.

ioctl(IOCTL_GENX320_SET_MODE, mode)

ioctl(IOCTL_GENX320_SET_MODE, mode, evt_res)

Alterna o sensor entre os modos de fotograma e de eventos. mode é uma das constantes GENX320_MODE_*. Para o modo de eventos, evt_res é o comprimento do eixo de linhas do buffer de eventos passado a IOCTL_GENX320_READ_EVENTS.

ioctl(IOCTL_GENX320_READ_EVENTS, buf)

Lê eventos para buf, um ndarray uint16 de forma (EVT_res, 6) onde EVT_res é uma potência de dois entre 1024 e 65536. As colunas são:

[0] – tipo de evento (PIX_OFF_EVENT / PIX_ON_EVENT / gatilho).
[1] – segundos.
[2] – milissegundos.
[3] – microssegundos.
[4] – coordenada x.
[5] – coordenada y.

Devolve o número de eventos escritos.

ioctl(IOCTL_GENX320_READ_EVENTS_RAW)

Devolve um image.Image com o fotograma de eventos bruto do GENX320.

ioctl(IOCTL_GENX320_CALIBRATE, iterations, sigma)

Desativa os pixels cujo ruído é superior a sigma desvios-padrão em relação à distribuição normal. iterations é o número inteiro de passes de calibração. Devolve o número de pixels desativados.

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

Define a paleta de cores a usar para coisas como a conversão FLIR Lepton em escala de cinzentos para RGB565 ou a visualização de eventos GENX320. Uma de image.PALETTE_RAINBOW, image.PALETTE_IRONBOW e (quando suportado) image.PALETTE_DEPTH, image.PALETTE_EVT_DARK ou image.PALETTE_EVT_LIGHT.

Devolve a definição atual se chamado sem argumentos.

__write_reg(address: int, value: int) → None#: Escreve value no registo da câmara no endereço address.

Nota
Consulte a folha de dados da câmara para informações sobre registos.

__read_reg(address: int) → int#: Lê o registo da câmara no endereço address.

Nota
Consulte a folha de dados da câmara para informações sobre registos.

Funções#

csi.devices() → List[int]#: Devolve uma lista dos IDs de chip do sensor detetados.

Constantes#

csi.BINARY: int#: Formato de pixel BINARY (bitmap). Cada pixel é 1 bit. Útil para armazenamento de máscaras; pode ser usado com image.Image().

csi.GRAYSCALE: int#: Formato de pixel GRAYSCALE (Y de YUV422). Cada pixel é 8 bits.

csi.RGB565: int#: Formato de pixel RGB565. Cada pixel é 16 bits (5 bits vermelho, 6 bits verde, 5 bits azul).

csi.BAYER: int#: Formato de pixel de imagem RAW BAYER.

csi.YUV422: int#: Formato de pixel YUV422. Cada pixel é armazenado como um valor Y em escala de cinzentos de 8 bits seguido de valores de cor U/V alternados de 8 bits partilhados entre dois valores Y (Y1, U, Y2, V, …). Apenas alguns métodos de processamento de imagem funcionam com YUV422.

csi.JPEG: int#: Modo JPEG. O módulo de câmara produz imagens JPEG comprimidas. Use CSI.quality para controlar a qualidade JPEG. Funciona apenas para as câmaras OV2640/OV5640.

csi.OV2640: int#: CSI.cid devolve este valor para a câmara OV2640.

csi.OV5640: int#: CSI.cid devolve este valor para a câmara OV5640.

csi.OV7670: int#: CSI.cid devolve este valor para a câmara OV7670.

csi.OV7690: int#: CSI.cid devolve este valor para a câmara OV7690.

csi.OV7725: int#: CSI.cid devolve este valor para a câmara OV7725.

csi.OV9650: int#: CSI.cid devolve este valor para a câmara OV9650.

csi.MT9V022: int#: CSI.cid devolve este valor para a câmara MT9V022.

csi.MT9V024: int#: CSI.cid devolve este valor para a câmara MT9V024.

csi.MT9V032: int#: CSI.cid devolve este valor para a câmara MT9V032.

csi.MT9V034: int#: CSI.cid devolve este valor para a câmara MT9V034.

csi.MT9M114: int#: CSI.cid devolve este valor para a câmara MT9M114.

csi.BOSON320: int#: CSI.cid devolve este valor para a câmara BOSON 320x256.

csi.BOSON640: int#: CSI.cid devolve este valor para a câmara BOSON 640x512.

csi.LEPTON: int#: CSI.cid devolve este valor para as câmaras LEPTON1/2/3.

csi.HM01B0: int#: CSI.cid devolve este valor para a câmara HM01B0.

csi.HM0360: int#: CSI.cid devolve este valor para a câmara HM0360.

csi.GC2145: int#: CSI.cid devolve este valor para a câmara GC2145.

csi.GENX320ES: int#: CSI.cid devolve este valor para a câmara GENX320 (amostra de engenharia).

csi.GENX320: int#: CSI.cid devolve este valor para a câmara GENX320.

csi.PAG7920: int#: CSI.cid devolve este valor para a câmara PAG7920.

csi.PAG7936: int#: CSI.cid devolve este valor para a câmara PAG7936.

csi.PAJ6100: int#: CSI.cid devolve este valor para a câmara PAJ6100.

csi.FROGEYE2020: int#: CSI.cid devolve este valor para a câmara FROGEYE2020.

csi.SOFTCSI: int#: CSI.cid devolve este valor para a câmara CSI por software.

csi.NORMAL: int#: Modo normal para CSI.special_effect.

csi.NEGATIVE: int#: Modo negativo para CSI.special_effect.

csi.QCIF: int#: Resolução 176x144 para o sensor de câmara.

csi.CIF: int#: Resolução 352x288 para o sensor de câmara.

csi.QSIF: int#: Resolução 176x120 para o sensor de câmara.

csi.SIF: int#: Resolução 352x240 para o sensor de câmara.

csi.QQQVGA: int#: Resolução 80x60 para o sensor de câmara.

csi.QQVGA: int#: Resolução 160x120 para o sensor de câmara.

csi.QVGA: int#: Resolução 320x240 para o sensor de câmara.

csi.VGA: int#: Resolução 640x480 para o sensor de câmara.

csi.HQVGA: int#: Resolução 240x160 para o sensor de câmara.

csi.HVGA: int#: Resolução 480x320 para o sensor de câmara.

csi.WVGA: int#: Resolução 720x480 para o sensor de câmara MT9V034.

csi.WVGA2: int#: Resolução 752x480 para o sensor de câmara MT9V034.

csi.SVGA: int#: Resolução 800x600 para o sensor de câmara.

csi.XGA: int#: Resolução 1024x768 para o sensor de câmara.

csi.WXGA: int#: Resolução 1280x768 para o sensor de câmara MT9M114.

csi.SXGA: int#: Resolução 1280x1024 para o sensor de câmara. Funciona apenas para as câmaras OV2640/OV5640.

csi.SXGAM: int#: Resolução 1280x960 para o sensor de câmara MT9M114.

csi.UXGA: int#: Resolução 1600x1200 para o sensor de câmara. Funciona apenas para as câmaras OV2640/OV5640.

csi.HD: int#: Resolução 1280x720 para o sensor de câmara.

csi.FHD: int#: Resolução 1920x1080 para o sensor de câmara. Funciona apenas para a câmara OV5640.

csi.QHD: int#: Resolução 2560x1440 para o sensor de câmara. Funciona apenas para a câmara OV5640.

csi.QXGA: int#: Resolução 2048x1536 para o sensor de câmara. Funciona apenas para a câmara OV5640.

csi.WQXGA: int#: Resolução 2560x1600 para o sensor de câmara. Funciona apenas para a câmara OV5640.

csi.WQXGA2: int#: Resolução 2592x1944 para o sensor de câmara. Funciona apenas para a câmara OV5640.

csi.IOCTL_SET_READOUT_WINDOW: int#: Define a janela de leitura. Consulte CSI.ioctl.

csi.IOCTL_GET_READOUT_WINDOW: int#: Obtém a janela de leitura. Consulte CSI.ioctl.

csi.IOCTL_SET_TRIGGERED_MODE: int#: Define o modo disparado para o MT9V034. Consulte CSI.ioctl.

csi.IOCTL_GET_TRIGGERED_MODE: int#: Obtém o estado do modo disparado para o MT9V034. Consulte CSI.ioctl.

csi.IOCTL_SET_FOV_WIDE: int#: Ativa CSI.framesize para otimizar para campo de visão em vez de FPS. Consulte CSI.ioctl.

csi.IOCTL_GET_FOV_WIDE: int#: Devolve se CSI.framesize está a otimizar para campo de visão em vez de FPS. Consulte CSI.ioctl.

csi.IOCTL_TRIGGER_AUTO_FOCUS: int#: Aciona a focagem automática no módulo de câmara OV5640 FPC. Consulte CSI.ioctl.

csi.IOCTL_PAUSE_AUTO_FOCUS: int#: Pausa a focagem automática (enquanto em execução) para o módulo de câmara OV5640 FPC. Consulte CSI.ioctl.

csi.IOCTL_RESET_AUTO_FOCUS: int#: Repõe a focagem automática para o valor predefinido para o módulo de câmara OV5640 FPC. Consulte CSI.ioctl.

csi.IOCTL_WAIT_ON_AUTO_FOCUS: int#: Aguarda que a focagem automática termine no módulo de câmara OV5640 FPC. Consulte CSI.ioctl.

csi.IOCTL_SET_NIGHT_MODE: int#: Liga ou desliga o modo noturno. Reduz a taxa de fotogramas para aumentar a exposição dinamicamente. Consulte CSI.ioctl.

csi.IOCTL_GET_NIGHT_MODE: int#: Devolve se o modo noturno está ativado. Consulte CSI.ioctl.

csi.IOCTL_LEPTON_GET_WIDTH: int#: Devolve a largura de resolução da imagem FLIR Lepton em pixels. Consulte CSI.ioctl.

csi.IOCTL_LEPTON_GET_HEIGHT: int#: Devolve a altura de resolução da imagem FLIR Lepton em pixels. Consulte CSI.ioctl.

csi.IOCTL_LEPTON_GET_RADIOMETRY: int#: Devolve o tipo do FLIR Lepton (radiométrico ou não). Consulte CSI.ioctl.

csi.IOCTL_LEPTON_GET_REFRESH: int#: Devolve a taxa de atualização do FLIR Lepton em Hz. Consulte CSI.ioctl.

csi.IOCTL_LEPTON_GET_RESOLUTION: int#: Devolve a resolução ADC do FLIR Lepton em bits. Consulte CSI.ioctl.

csi.IOCTL_LEPTON_RUN_COMMAND: int#: Executa um comando de 16 bits do SDK FLIR Lepton. Consulte CSI.ioctl.

csi.IOCTL_LEPTON_SET_ATTRIBUTE: int#: Define um atributo do FLIR Lepton a partir do SDK FLIR Lepton. Consulte CSI.ioctl.

csi.IOCTL_LEPTON_GET_ATTRIBUTE: int#: Obtém um atributo do FLIR Lepton a partir do SDK FLIR Lepton. Consulte CSI.ioctl.

csi.IOCTL_LEPTON_GET_FPA_TEMP: int#: Obtém a temperatura FPA do FLIR Lepton em Celsius. Consulte CSI.ioctl.

csi.IOCTL_LEPTON_GET_AUX_TEMP: int#: Obtém a temperatura AUX do FLIR Lepton em Celsius. Consulte CSI.ioctl.

csi.IOCTL_LEPTON_SET_MODE: int#: Coloca o controlador FLIR Lepton num modo em que cada pixel é um valor de temperatura. Consulte CSI.ioctl.

csi.IOCTL_LEPTON_GET_MODE: int#: Devolve se o modo de medição está ativado para o sensor FLIR Lepton. Consulte CSI.ioctl.

csi.IOCTL_LEPTON_SET_RANGE: int#: Define o intervalo de temperatura mapeado para valores de pixel no modo de medição. Consulte CSI.ioctl.

csi.IOCTL_LEPTON_GET_RANGE: int#: Devolve o intervalo de temperatura utilizado para o modo de medição. Consulte CSI.ioctl.

csi.IOCTL_HIMAX_MD_ENABLE: int#: Controla a interrupção de deteção de movimento no HM01B0. Consulte CSI.ioctl.

csi.IOCTL_HIMAX_MD_WINDOW: int#: Define a janela de deteção de movimento no HM01B0. Consulte CSI.ioctl.

csi.IOCTL_HIMAX_MD_THRESHOLD: int#: Define o limiar de deteção de movimento no HM01B0. Consulte CSI.ioctl.

csi.IOCTL_HIMAX_MD_CLEAR: int#: Limpa a interrupção de deteção de movimento no HM01B0. Consulte CSI.ioctl.

csi.IOCTL_HIMAX_OSC_ENABLE: int#: Controla o oscilador interno no HM01B0. Consulte CSI.ioctl.

csi.IOCTL_GET_RGB_STATS: int#: Devolve as estatísticas RGB do sensor de câmara. Consulte CSI.ioctl.

csi.IOCTL_GENX320_SET_BIASES: int#: Define as polarizações do sensor GENX320 para um dos predefinidos GENX320_BIASES_*. Consulte CSI.ioctl. Após CSI.reset, o controlador aplica csi.GENX320_BIASES_LOW_NOISE, não csi.GENX320_BIASES_DEFAULT — use este ioctl para mudar para um predefinido diferente quando a aplicação precisar de maior sensibilidade ou largura de banda.

csi.GENX320_BIASES_DEFAULT: int#: Predefinições da folha de dados GenX320 — sensibilidade, ruído e largura de banda equilibrados para cenas gerais.

csi.GENX320_BIASES_LOW_LIGHT: int#: Otimizado para condições de baixa luminosidade — ambos os limiares de contraste alargados para maior sensibilidade, FO reduzido, HPF desativado para que mudanças lentas de brilho ainda sejam registadas.

csi.GENX320_BIASES_ACTIVE_MARKER: int#: Otimizado para rastrear LEDs intermitentes de alto contraste (marcadores ativos) — limiares de contraste elevados para que apenas transições nítidas disparem, FO e HPF aumentados para maximizar a largura de banda e rejeitar a deriva ambiente lenta, REFR=0 para que cada bordo de intermitência seja capturado.

csi.GENX320_BIASES_LOW_NOISE: int#: Predefinição do controlador — sensibilidade inferior ao DEFAULT (limiares de contraste elevados) e um FO mais baixo para menor atividade de ruído de fundo. Melhor para cenas estáticas ou lentas onde eventos falsos dominariam.

csi.GENX320_BIASES_HIGH_SPEED: int#: Otimizado para cenas de movimento rápido — FO mais alto para maior largura de banda de pixel, HPF mais alto para rejeitar mudanças lentas, REFR mais alto para um tempo morto mais longo após cada evento para que a leitura não sature.

csi.IOCTL_GENX320_SET_BIAS: int#: Define uma única polarização do sensor GENX320 para um valor DAC. Passe uma constante GENX320_BIAS_* (csi.GENX320_BIAS_DIFF_OFF, csi.GENX320_BIAS_DIFF_ON, csi.GENX320_BIAS_FO, csi.GENX320_BIAS_HPF ou csi.GENX320_BIAS_REFR) e um valor inteiro DAC. Cada polarização é independente — chame este ioctl repetidamente para ajustar apenas as polarizações necessárias após aplicar um predefinido. Consulte CSI.ioctl.

csi.GENX320_BIAS_DIFF_OFF: int#: Limiar de contraste negativo do comparador — controla o quanto um pixel tem de escurecer antes de um csi.PIX_OFF_EVENT ser disparado. Valor mais baixo = mais sensível (mais eventos).

csi.GENX320_BIAS_DIFF_ON: int#: Limiar de contraste positivo do comparador — controla o quanto um pixel tem de clarear antes de um csi.PIX_ON_EVENT ser disparado. Valor mais baixo = mais sensível (mais eventos).

csi.GENX320_BIAS_FO: int#: Frequência de corte passa-baixo do pixel — compromisso entre a largura de banda do pixel (velocidade/latência) e a atividade de ruído de fundo. Valor mais alto = resposta de pixel mais rápida, mais ruído.

csi.GENX320_BIAS_HPF: int#: Frequência de corte passa-alto do pixel — rejeita mudanças lentas de brilho. Valor mais alto = mudanças mais lentas filtradas (apenas transições rápidas são registadas).

csi.GENX320_BIAS_REFR: int#: Período refratário do pixel — tempo morto após um pixel emitir um evento durante o qual não pode disparar novamente. Valor mais alto = tempo morto mais longo, menos eventos de um pixel muito ativo.

csi.IOCTL_GENX320_SET_AFK: int#: Define o filtro anti-cintilação (AFK) do GENX320, que rejeita eventos de pixels que alternam a uma banda de frequência periódica (iluminação fluorescente, ecrãs controlados por LED, etc.). Passe enable (1 para ativar, 0 para desativar) e, ao ativar, as extremidades da banda em hertz: (enable, freq_low_hz, freq_high_hz). Consulte CSI.ioctl.

csi.IOCTL_GENX320_SET_STC: int#: Define o modo do filtro de contraste espácio-temporal (STC) do GENX320. Passe uma constante GENX320_STC_* (csi.GENX320_STC_DISABLE, csi.GENX320_STC_ONLY, csi.GENX320_STC_TRAIL_ONLY, csi.GENX320_STC_TRAIL) seguida dos limiares que o modo requer (em milissegundos). Consulte CSI.ioctl.

csi.GENX320_STC_DISABLE: int#: Desativa o filtro STC/trail do GENX320 — todos os eventos passam.

csi.GENX320_STC_ONLY: int#: Mantém o segundo evento de uma rajada; descarta o primeiro evento e quaisquer eventos posteriores. Recebe um parâmetro, stc_threshold em milissegundos — eventos dentro dessa janela de um evento anterior no mesmo pixel são considerados parte da mesma rajada.

csi.GENX320_STC_TRAIL_ONLY: int#: Mantém o primeiro evento de uma rajada; descarta eventos subsequentes no mesmo pixel até que trail_threshold tenha decorrido. Recebe um parâmetro, trail_threshold em milissegundos.

csi.GENX320_STC_TRAIL: int#: Mantém o primeiro evento de uma rajada mais as arestas subsequentes — combina csi.GENX320_STC_ONLY e csi.GENX320_STC_TRAIL_ONLY. Recebe dois parâmetros, stc_threshold e trail_threshold (ambos em ms); o sensor requer que os dois permaneçam dentro de uma proporção aproximada de 13:1.

csi.IOCTL_GENX320_SET_MODE: int#: Define o modo de operação do GENX320. Passe csi.GENX320_MODE_HISTO para o histograma de eventos no chip (a câmara comporta-se como uma câmara em escala de cinzentos normal à taxa de fotogramas configurada) ou csi.GENX320_MODE_EVENT seguido do comprimento do eixo de linhas do ndarray de eventos (uma potência de dois entre 1024 e 65536) para streaming de eventos brutos. Consulte CSI.ioctl.

csi.GENX320_MODE_HISTO: int#: Modo histograma — os eventos são acumulados no chip em contadores por pixel e reportados como um fotograma em escala de cinzentos 320x320 à taxa configurada (~20-350 FPS). A câmara parece uma câmara normal, pelo que todas as rotinas padrão de processamento de imagem funcionam diretamente.

csi.GENX320_MODE_EVENT: int#: Modo de eventos — ignora o histograma no chip e transmite eventos brutos para um ndarray numpy com marcações de tempo de microssegundos, para aplicações que precisam de detalhe temporal completo em vez de um fotograma pré-agregado.

csi.IOCTL_GENX320_READ_EVENTS: int#: Lê eventos brutos para um ndarray uint16 de forma (EVT_res, 6) (com EVT_res correspondendo ao tamanho do buffer passado a csi.IOCTL_GENX320_SET_MODE). As colunas são [0] tipo de evento (csi.PIX_OFF_EVENT, csi.PIX_ON_EVENT, csi.EXT_TRIGGER_RISING/FALLING, csi.RST_TRIGGER_RISING/FALLING), [1] marcação de tempo em segundos, [2] milissegundos, [3] microssegundos, [4] coordenada X (0-319), [5] coordenada Y (0-319). Devolve o número de eventos escritos no buffer, deixando as linhas mais antigas além desse count intocadas. Consulte CSI.ioctl.

csi.IOCTL_GENX320_CALIBRATE: int#: Desativa automaticamente os pixels quentes — pixels que disparam de forma espúria mesmo numa cena estática. O controlador cria um mapa de contagem de acertos por pixel 320x320, calcula a média e o desvio padrão, e desativa qualquer pixel cuja contagem exceda mean + sigma * stddev. Passe um orçamento de contagem de eventos (eventos a contabilizar antes de calcular as estatísticas — maior = estimativa mais fiável, mais lento; ~10000 é um bom valor predefinido) e um float sigma (menor = mais agressivo, ~0.5 predefinido). Devolve o número de pixels desativados. Aponte a câmara para uma cena estática primeiro para que os eventos causados por movimento não sejam contabilizados contra pixels que estão realmente bem. Consulte CSI.ioctl.

csi.IOCTL_GENX320_READ_EVENTS_RAW: int#: Devolve um image.Image de fotograma de eventos bruto do GENX320, com os eventos ainda na codificação nativa empacotada do chip — útil se pretender encaminhar o stream bruto para um PC para descodificação offline em vez de o processar na câmara. Consulte CSI.ioctl.

csi.PIX_OFF_EVENT: int#: Tipo de evento GENX320 (coluna [0]) — um pixel detetou uma diminuição de brilho (o limiar de contraste negativo foi cruzado). As colunas [4]/[5] transportam as coordenadas X/Y do pixel.

csi.PIX_ON_EVENT: int#: Tipo de evento GENX320 (coluna [0]) — um pixel detetou um aumento de brilho (o limiar de contraste positivo foi cruzado). As colunas [4]/[5] transportam as coordenadas X/Y do pixel.

csi.RST_TRIGGER_RISING: int#: Tipo de evento GENX320 (coluna [0]) — gatilho de reset de pixel, bordo ascendente. X/Y não são utilizados. Não é gerado pelo firmware neste momento.

csi.RST_TRIGGER_FALLING: int#: Tipo de evento GENX320 (coluna [0]) — gatilho de reset de pixel, bordo descendente. X/Y não são utilizados. Não é gerado pelo firmware neste momento.

csi.EXT_TRIGGER_RISING: int#: Tipo de evento GENX320 (coluna [0]) — o pino de gatilho externo do sensor detetou um bordo ascendente. A entrada de gatilho externo do GENX320 está ligada à linha de sincronização de fotogramas da câmara, também encaminhada para P10 no processador e no conector de pinos. X/Y não são utilizados.

csi.EXT_TRIGGER_FALLING: int#: Tipo de evento GENX320 (coluna [0]) — o pino de gatilho externo do sensor detetou um bordo descendente. A entrada de gatilho externo do GENX320 está ligada à linha de sincronização de fotogramas da câmara, também encaminhada para P10 no processador e no conector de pinos. X/Y não são utilizados.

csi — sensores de câmara#

Utilização com Asyncio#

class CSI – Interface do Sensor de Câmara#

Métodos#

Funções#

Constantes#

`csi` — sensores de câmara#