image_transfer_raw_as_the_controller_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 contrôleur
#
# Ce script est conçu pour être associé à une autre OpenMV Cam exécutant "image_transfer_raw_as_the_remote_device.py"
#
# Ce script montre comment transférer le tampon d'image (frame buffer) d'une OpenMV Cam à une autre.
import image
import omv
import rpc
import csi
import struct
import time
# La bibliothèque RPC mentionnée ci-dessus est installée sur votre caméra OpenMV et fournit plusieurs classes
# permettant à votre OpenMV Cam de contrôler via CAN, I2C, SPI, UART ou LAN/WLAN.
##############################################################
# Choisissez l'interface que vous souhaitez utiliser pour contrôler une OpenMV Cam.
##############################################################
# Décommentez la ligne ci-dessous pour configurer votre OpenMV Cam afin de la contrôler 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_master(message_id=0x7FF, bit_rate=1000000, sample_point=75.0)
# Décommentez la ligne ci-dessous pour configurer votre OpenMV Cam afin de la contrôler via I2C.
#
# * slave_addr - adresse I2C.
# * rate - Fréquence d'horloge du bus 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_master(slave_addr=0x12, rate=1000000)
# Décommentez la ligne ci-dessous pour configurer votre OpenMV Cam afin de la contrôler via SPI.
#
# * cs_pin - broche de sélection de l'esclave (Slave Select).
# * freq - Fréquence d'horloge du bus SPI
# * 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_master(cs_pin="P3", freq=20000000, clk_polarity=1, clk_phase=0)
# Décommentez la ligne ci-dessous pour configurer votre OpenMV Cam afin de la contrôler 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_master(baudrate=7500000)
##############################################################
# Gestionnaires de callbacks
##############################################################
def get_frame_buffer_call_back(pixformat, framesize, cutthrough, silent):
if not silent:
print("Getting Remote Frame...")
result = interface.call(
"raw_image_snapshot", struct.pack("<II", pixformat, framesize)
)
if result is not None:
w, h, pixformat, size = struct.unpack("<IIII", result)
img = image.Image(w, h, pixformat, copy_to_fb=True) # Alloue un tampon d'image effacé (mis à zéro).
img_ba = img.bytearray()
if cutthrough:
# Transfert de données rapide en mode direct (cutthrough) sans vérification d'erreur.
# Avant de démarrer le transfert de données en mode direct, nous devons synchroniser à la fois le maître et
# l'esclave. Au retour, les deux périphériques sont synchronisés.
result = interface.call("raw_image_read")
if result is not None:
# GET BYTES DOIT S'EXÉCUTER IMMÉDIATEMENT APRÈS, AVEC TRÈS PEU DE DÉLAI.
# Lit toutes les données de l'image en un seul très grand transfert.
interface.get_bytes(img_ba, 5000) # délai d'attente (timeout)
else:
# Transfert de données plus lent avec vérification d'erreur.
# Transfère des blocs de 32/8 KB.
chunk_size = (1 << 15) if omv.board_type() == "H7" else (1 << 13)
if not silent:
print("Reading %d bytes..." % size)
for i in range(0, size, chunk_size):
ok = False
for j in range(3): # Essaie jusqu'à 3 fois.
result = interface.call(
"raw_image_read", struct.pack("<II", i, chunk_size)
)
if result is not None:
img_ba[i:i + chunk_size] = result # Écrit les données de l'image.
if not silent:
print("%.2f%%" % ((i * 100) / size))
ok = True
break
if not silent:
print("Retrying... %d/2" % (j + 1))
if not ok:
if not silent:
print("Error!")
return None
return img
else:
if not silent:
print("Failed to get Remote Frame!")
return None
clock = time.clock()
while True:
clock.tick()
# Vous pouvez modifier le pixformat et le framesize de l'image transférée depuis le périphérique distant
# en modifiant les arguments ci-dessous.
#
# Lorsque cutthrough vaut False, l'image sera transférée via la bibliothèque RPC avec une protection CRC et
# de nouvelle tentative sur toutes les données déplacées. Pour un transfert de données plus rapide, définissez cutthrough sur True afin que
# get_bytes() et put_bytes() soient appelées une fois l'appel RPC terminé pour transférer les données
# plus rapidement d'un tampon d'image à un autre. Remarque : cela fonctionne car, une fois qu'un appel RPC
# se termine avec succès, le maître et l'esclave sont entièrement synchronisés.
#
img = get_frame_buffer_call_back(
csi.RGB565, csi.QQVGA, cutthrough=True, silent=True
)
if img is not None:
pass # Vous pouvez traiter l'image ici.
print(clock.fps())