image_transfer_raw_as_the_remote_device.py

# Este trabalho está licenciado sob a licença MIT.
# Copyright (c) 2013-2023 OpenMV LLC. Todos os direitos reservados.
# https://github.com/openmv/openmv/blob/master/LICENSE
#
# Transferência de imagem - Como o dispositivo remoto
#
# Este script foi feito para ser combinado com outra OpenMV Cam rodando "image_transfer_raw_as_the_controller_device.py"
#
# Este script mostra como transferir o frame buffer de uma OpenMV Cam para outra.

import rpc
import csi
import struct

csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.QVGA)
csi0.snapshot(time=2000)

# A biblioteca RPC acima está instalada na sua OpenMV Cam e fornece diversas classes para
# permitindo que sua OpenMV Cam seja controlada via CAN, I2C, SPI, UART ou LAN/WLAN.

################################################################
# Escolha a interface pela qual deseja controlar a sua OpenMV Cam.
################################################################

# Descomente a linha abaixo para configurar sua OpenMV Cam para controle via CAN.
#
# * message_id - Mensagem CAN usada para transporte de dados no barramento CAN (11 bits).
# * bit_rate - Taxa de bits do CAN.
# * sample_point - Proporção Tseg1/Tseg2. Tipicamente 75%. (50.0, 62.5, 75.0, 87.5, etc.)
#
# NOTA: Os message ids e as taxas de bits do CAN do mestre e do escravo devem coincidir. Conecte o can high do mestre ao
# can high do escravo e o can low do mestre ao can low do escravo. O barramento CAN deve ser terminado com 120 ohms.
#
# interface = rpc.rpc_can_slave(message_id=0x7FF, bit_rate=1000000, sample_point=75.0)

# Descomente a linha abaixo para configurar sua OpenMV Cam para controle via I2C.
#
# * slave_addr - Endereço I2C.
#
# NOTA: Os endereços do mestre e do escravo devem coincidir. Conecte o scl do mestre ao scl do escravo e o sda do mestre
# ao sda do escravo. É necessário usar pull-ups externos. Por fim, ambos os dispositivos devem compartilhar um ground.
#
# interface = rpc.rpc_i2c_slave(slave_addr=0x12)

# Descomente a linha abaixo para configurar sua OpenMV Cam para controle via SPI.
#
# * cs_pin - Pino de seleção do escravo (Slave Select).
# * clk_polarity - Nível do clock em repouso (0 ou 1).
# * clk_phase - Amostra dados na primeira (0) ou segunda borda (1) do clock.
#
# NOTA: As configurações do mestre e do escravo devem coincidir. Conecte CS, SCLK, MOSI, MISO a CS, SCLK, MOSI, MISO.
# Por fim, ambos os dispositivos devem compartilhar um ground comum.
#
interface = rpc.rpc_spi_slave(cs_pin="P3", clk_polarity=1, clk_phase=0)

# Descomente a linha abaixo para configurar sua OpenMV Cam para controle via UART.
#
# * baudrate - Taxa de transmissão serial.
#
# NOTA: As taxas de baud do mestre e do escravo devem coincidir. Conecte o tx do mestre ao rx do escravo e o rx do mestre ao
# tx do escravo. Por fim, ambos os dispositivos devem compartilhar um ground comum.
#
# interface = rpc.rpc_uart_slave(baudrate=7500000)

################################################################
# Call Backs
################################################################
img = None
img_ba = None
img_mv = None


# Quando chamado, define o pixformat e o framesize, captura uma imagem
# e então retorna o formato do frame buffer para armazenar a imagem.
#
# data são 4 bytes de pixformat e 4 bytes de framesize.
def raw_image_snapshot(data):
    global img, img_ba, img_mv
    pixformat, framesize = struct.unpack("<II", data)
    csi0.pixformat(pixformat)
    csi0.framesize(framesize)
    img = csi0.snapshot()
    img_ba = img.bytearray()
    img_mv = memoryview(img_ba)
    return struct.pack(
        "<IIII", csi0.width(), csi0.height(), csi0.pixformat(), img.size()
    )


def raw_image_read_cb():
    interface.put_bytes(img_ba, 5000)  # timeout


# Ler dados do frame buffer dado um offset e um tamanho.
# Se data estiver vazio, uma transferência é agendada após o término da chamada RPC.
#
# data são 4 bytes de tamanho e 4 bytes de offset.
def raw_image_read(data):
    if not len(data):
        interface.schedule_callback(raw_image_read_cb)
        return bytes()
    else:
        offset, size = struct.unpack("<II", data)
        return img_mv[offset:offset + size]


# Registrar call backs.

interface.register_callback(raw_image_snapshot)
interface.register_callback(raw_image_read)

# Depois que todos os call backs forem registrados, podemos iniciar
# o processamento de eventos remotos. interface.loop() não retorna.

interface.loop()