image_transfer_raw_as_the_remote_device.py

# Questo lavoro è concesso in licenza MIT.
# Copyright (c) 2013-2023 OpenMV LLC. Tutti i diritti riservati.
# https://github.com/openmv/openmv/blob/master/LICENSE
#
# Trasferimento immagini - Come dispositivo remoto
#
# Questo script è pensato per essere abbinato a un'altra OpenMV Cam che esegue "image_transfer_raw_as_the_controller_device.py"
#
# Questo script mostra come trasferire il frame buffer da una OpenMV Cam a un'altra.

import rpc
import csi
import struct

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

# La libreria RPC sopra indicata è installata sulla tua OpenMV Cam e fornisce diverse classi per
# permettendo il controllo della tua OpenMV Cam tramite CAN, I2C, SPI, UART o LAN/WLAN.

################################################################
# Scegli l'interfaccia tramite cui vuoi controllare la tua OpenMV Cam.
################################################################

# Rimuovi il commento dalla riga seguente per configurare la tua OpenMV Cam per il controllo via CAN.
#
# * message_id - messaggio CAN da usare per il trasporto dati sul bus can (11 bit).
# * bit_rate - velocità di trasmissione (bit rate) CAN.
# * sample_point - rapporto Tseg1/Tseg2. Tipicamente 75%. (50.0, 62.5, 75.0, 87.5, ecc.)
#
# NOTA: gli id dei messaggi e i bit rate can di master e slave devono corrispondere. Collega il can high del master allo
# can high dello slave e il can low del master al can low dello slave. Il bus can deve essere terminato con 120 ohm.
#
# interface = rpc.rpc_can_slave(message_id=0x7FF, bit_rate=1000000, sample_point=75.0)

# Rimuovi il commento dalla riga seguente per configurare la tua OpenMV Cam per il controllo via I2C.
#
# * slave_addr - indirizzo I2C.
#
# NOTA: gli indirizzi di master e slave devono corrispondere. Collega lo scl del master allo scl dello slave e lo sda del master
# allo sda dello slave. Devi usare pull-up esterni. Infine, entrambi i dispositivi devono condividere una massa comune.
#
# interface = rpc.rpc_i2c_slave(slave_addr=0x12)

# Rimuovi il commento dalla riga seguente per configurare la tua OpenMV Cam per il controllo via SPI.
#
# * cs_pin - pin di selezione dello slave (Slave Select).
# * clk_polarity - livello del clock a riposo (0 o 1).
# * clk_phase - campiona i dati sul primo (0) o secondo fronte (1) del clock.
#
# NOTA: le impostazioni di master e slave devono corrispondere. Collega CS, SCLK, MOSI, MISO a CS, SCLK, MOSI, MISO.
# Infine, entrambi i dispositivi devono condividere una massa comune.
#
interface = rpc.rpc_spi_slave(cs_pin="P3", clk_polarity=1, clk_phase=0)

# Rimuovi il commento dalla riga seguente per configurare la tua OpenMV Cam per il controllo via UART.
#
# * baudrate - velocità di trasmissione seriale (baudrate).
#
# NOTA: i baudrate di master e slave devono corrispondere. Collega il tx del master all'rx dello slave e l'rx del master
# al tx dello slave. Infine, entrambi i dispositivi devono condividere una massa comune.
#
# interface = rpc.rpc_uart_slave(baudrate=7500000)

################################################################
# Callback
################################################################
img = None
img_ba = None
img_mv = None


# Se chiamata imposta il pixformat e il framesize, acquisisce uno snapshot
# e poi restituisce la forma del frame buffer in cui memorizzare l'immagine.
#
# data è composto da un pixformat a 4 byte e un framesize a 4 byte.
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


# Legge i dati dal frame buffer dati un offset e una dimensione.
# Se data è vuoto, viene pianificato un trasferimento al termine della chiamata RPC.
#
# data è composto da una dimensione a 4 byte e un offset a 4 byte.
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]


# Registra i callback.

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

# Una volta registrati tutti i callback possiamo iniziare
# a elaborare gli eventi remoti. interface.loop() non ritorna.

interface.loop()