image_transfer_raw_as_the_remote_device.py

# Esta obra está licenciada bajo la licencia MIT.
# Copyright (c) 2013-2023 OpenMV LLC. Todos los derechos reservados.
# https://github.com/openmv/openmv/blob/master/LICENSE
#
# Transferencia de imagen - Como dispositivo remoto
#
# Este script está diseñado para emparejarse con otra OpenMV Cam que ejecute "image_transfer_raw_as_the_controller_device.py"
#
# Este script muestra cómo transferir el framebuffer de una OpenMV Cam a otra.

import rpc
import csi
import struct

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

# La biblioteca RPC mencionada arriba está instalada en su OpenMV Cam y proporciona varias clases para
# permitiendo que su OpenMV Cam sea controlada mediante CAN, I2C, SPI, UART o LAN/WLAN.

################################################################
# Elija la interfaz mediante la cual desea controlar su OpenMV Cam.
################################################################

# Descomente la línea de abajo para configurar su OpenMV Cam para controlarla por CAN.
#
# * message_id: mensaje CAN que se usará para el transporte de datos en el bus CAN (11 bits).
# * bit_rate: velocidad de bits del CAN.
# * sample_point - Relación Tseg1/Tseg2. Típicamente 75%. (50.0, 62.5, 75.0, 87.5, etc.)
#
# NOTA: los IDs de mensaje y las velocidades de bits CAN del maestro y del esclavo deben coincidir. Conecte el can high del maestro al
# can high del esclavo, y el can low del maestro al can low del esclavo. El bus CAN debe terminarse con 120 ohmios.
#
# interface = rpc.rpc_can_slave(message_id=0x7FF, bit_rate=1000000, sample_point=75.0)

# Descomente la línea de abajo para configurar su OpenMV Cam para controlarla por I2C.
#
# * slave_addr: dirección I2C.
#
# NOTA: las direcciones del maestro y del esclavo deben coincidir. Conecte el scl del maestro al scl del esclavo y el sda del maestro
# al sda del esclavo. Debe usar resistencias pull-up externas. Finalmente, ambos dispositivos deben compartir una tierra común.
#
# interface = rpc.rpc_i2c_slave(slave_addr=0x12)

# Descomente la línea de abajo para configurar su OpenMV Cam para controlarla por SPI.
#
# * cs_pin: pin de selección de esclavo (Slave Select).
# * clk_polarity: nivel del reloj en reposo (0 o 1).
# * clk_phase: muestrear los datos en el primer (0) o segundo flanco (1) del reloj.
#
# NOTA: la configuración del maestro y del esclavo debe coincidir. Conecte CS, SCLK, MOSI, MISO a CS, SCLK, MOSI, MISO.
# Finalmente, ambos dispositivos deben compartir una tierra común.
#
interface = rpc.rpc_spi_slave(cs_pin="P3", clk_polarity=1, clk_phase=0)

# Descomente la línea de abajo para configurar su OpenMV Cam para controlarla por UART.
#
# * baudrate: velocidad en baudios del puerto serie.
#
# NOTA: las velocidades en baudios del maestro y del esclavo deben coincidir. Conecte el tx del maestro al rx del esclavo y el rx del maestro
# al tx del esclavo. Finalmente, ambos dispositivos deben compartir una tierra común.
#
# interface = rpc.rpc_uart_slave(baudrate=7500000)

################################################################
# Funciones de callback
################################################################
img = None
img_ba = None
img_mv = None


# Cuando se llama, establece el pixformat y framesize, toma una instantánea
# y luego devuelve la forma del framebuffer donde se almacenará la imagen.
#
# data es un pixformat de 4 bytes y un framesize de 4 bytes.
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


# Lee datos del framebuffer dado un offset y un tamaño.
# Si data está vacío, se programa una transferencia después de que finalice la llamada RPC.
#
# data es un tamaño de 4 bytes y un offset de 4 bytes.
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 funciones callback.

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

# Una vez registradas todas las funciones callback, podemos comenzar
# a procesar eventos remotos. interface.loop() no retorna.

interface.loop()