image_transfer_raw_as_the_remote_device.py

# Ce travail est publié sous licence MIT.
# Copyright (c) 2013-2023 OpenMV LLC. Tous droits réservés.
# https://github.com/openmv/openmv/blob/master/LICENSE
#
# Transfert d'image - En tant que périphérique distant
#
# Ce script est conçu pour être associé à une autre OpenMV Cam exécutant "image_transfer_raw_as_the_controller_device.py"
#
# Ce script montre comment transférer le tampon d'image (frame buffer) d'une OpenMV Cam à une autre.

import rpc
import csi
import struct

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

# La bibliothèque RPC mentionnée ci-dessus est installée sur votre caméra OpenMV et fournit plusieurs classes
# permettant de contrôler votre OpenMV Cam via CAN, I2C, SPI, UART ou LAN/WLAN.

################################################################
# Choisissez l'interface que vous souhaitez utiliser pour contrôler votre caméra OpenMV.
################################################################

# Décommentez la ligne ci-dessous pour configurer votre caméra OpenMV pour un contrôle via CAN.
#
# * message_id - message CAN à utiliser pour le transport de données sur le bus CAN (11 bits).
# * bit_rate - débit binaire du bus CAN.
# * sample_point - Ratio Tseg1/Tseg2. Généralement 75%. (50.0, 62.5, 75.0, 87.5, etc.)
#
# REMARQUE : les identifiants de message et débits binaires CAN du maître et de l'esclave doivent correspondre. Reliez le CAN high du maître au CAN high
# de l'esclave et le CAN low du maître au CAN low de l'esclave. Le bus CAN doit être terminé avec une résistance de 120 ohms.
#
# interface = rpc.rpc_can_slave(message_id=0x7FF, bit_rate=1000000, sample_point=75.0)

# Décommentez la ligne ci-dessous pour configurer votre caméra OpenMV pour un contrôle via I2C.
#
# * slave_addr - adresse I2C.
#
# REMARQUE : les adresses du maître et de l'esclave doivent correspondre. Reliez le scl du maître au scl de l'esclave et le sda du maître
# au sda de l'esclave. Vous devez utiliser des résistances de tirage (pull-up) externes. Enfin, les deux appareils doivent partager une masse commune.
#
# interface = rpc.rpc_i2c_slave(slave_addr=0x12)

# Décommentez la ligne ci-dessous pour configurer votre caméra OpenMV pour un contrôle via SPI.
#
# * cs_pin - broche de sélection de l'esclave (Slave Select).
# * clk_polarity - niveau d'horloge au repos (0 ou 1).
# * clk_phase - échantillonner les données sur le premier (0) ou le second front (1) de l'horloge.
#
# REMARQUE : les réglages du maître et de l'esclave doivent correspondre. Reliez CS, SCLK, MOSI, MISO à CS, SCLK, MOSI, MISO.
# Enfin, les deux appareils doivent partager une masse commune.
#
interface = rpc.rpc_spi_slave(cs_pin="P3", clk_polarity=1, clk_phase=0)

# Décommentez la ligne ci-dessous pour configurer votre caméra OpenMV pour un contrôle via UART.
#
# * baudrate - vitesse de transmission série.
#
# REMARQUE : les vitesses de transmission du maître et de l'esclave doivent correspondre. Reliez le tx du maître au rx de l'esclave et le rx du maître
# au tx de l'esclave. Enfin, les deux appareils doivent partager une masse commune.
#
# interface = rpc.rpc_uart_slave(baudrate=7500000)

################################################################
# Fonctions de rappel (Call Backs)
################################################################
img = None
img_ba = None
img_mv = None


# Lorsqu'elle est appelée, définit le pixformat et le framesize, prend une capture
# puis retourne la forme du tampon d'image dans lequel stocker l'image.
#
# data est un pixformat de 4 octets et un framesize de 4 octets.
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)  # délai d'attente (timeout)


# Lit des données du tampon d'image à partir d'un décalage (offset) et d'une taille donnés.
# Si data est vide, un transfert est planifié une fois l'appel RPC terminé.
#
# data est une taille de 4 octets et un décalage (offset) de 4 octets.
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]


# Enregistre les callbacks.

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

# Une fois tous les callbacks enregistrés, nous pouvons commencer
# à traiter les événements distants. interface.loop() ne retourne jamais.

interface.loop()