popular_features_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
#
# Contrôle à distance - En tant que périphérique contrôleur
#
# Ce script configure votre OpenMV Cam pour contrôler à distance une autre OpenMV Cam à l'aide de la RPC
# bibliothèque. Ce script peut être exécuté par n'importe quelle carte MicroPython implémentant le module pyb pour
# contrôler à distance une OpenMV Cam.
#
# Ce script est conçu pour être associé à "popular_features_as_the_remote_device.py".

import json
import rpc
import struct

# 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 ou UART.

##############################################################
# 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. Typiquement 75 %. (50,0, 62,5, 75, 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=250000, sample_point=75)

# 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=100000)

# 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=10000000, 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=115200)

##############################################################
# Gestionnaires de callbacks
##############################################################


def exe_face_detection():
    result = interface.call("face_detection")
    if result is not None and len(result):
        print(
            "Largest Face Detected [x=%d, y=%d, w=%d, h=%d]"
            % struct.unpack("<HHHH", result)
        )


def exe_qrcode_detection():
    result = interface.call("qrcode_detection")
    if result is not None and len(result):
        print(bytes(result).decode())


def exe_all_qrcode_detection():
    result = interface.call("all_qrcode_detection")
    if result is not None and len(result):
        print("QR Codes Detected:")
        for obj in json.loads(result):
            print(obj)


def exe_apriltag_detection():
    result = interface.call("apriltag_detection")
    if result is not None and len(result):
        print(
            "Largest Tag Detected [cx=%d, cy=%d, id=%d, rot=%d]"
            % struct.unpack("<HHHH", result)
        )


def exe_all_apriltag_detection():
    result = interface.call("all_apriltag_detection")
    if result is not None and len(result):
        print("Tags Detected:")
        for obj in json.loads(result):
            print(obj)


def exe_datamatrix_detection():
    result = interface.call("datamatrix_detection")
    if result is not None and len(result):
        print(bytes(result).decode())


def exe_all_datamatrix_detection():
    result = interface.call("all_datamatrix_detection")
    if result is not None and len(result):
        print("Data Matrices Detected:")
        for obj in json.loads(result):
            print(obj)


def exe_barcode_detection():
    result = interface.call("barcode_detection")
    if result is not None and len(result):
        print(bytes(result).decode())


def exe_all_barcode_detection():
    result = interface.call("all_barcode_detection")
    if result is not None and len(result):
        print("Bar Codes Detected:")
        for obj in json.loads(result):
            print(obj)


def exe_color_detection():
    thresholds = (30, 100, 15, 127, 15, 127)  # seuils génériques pour le rouge
    # thresholds = (30, 100, -64, -8, -32, 32) # seuils génériques pour le vert
    # thresholds = (0, 30, 0, 64, -128, 0) # seuils génériques pour le bleu
    result = interface.call("color_detection", struct.pack("<bbbbbb", *thresholds))
    if result is not None and len(result):
        print("Largest Color Detected [cx=%d, cy=%d]" % struct.unpack("<HH", result))


number = 0


def exe_jpeg_snapshot():
    global number
    result = interface.call("jpeg_snapshot")
    if result is not None:
        name = "snapshot-%05d.jpg" % number
        print("Writing jpeg %s..." % name)
        with open(name, "wb") as snap:
            snap.write(result)
            number += 1


# Exécute des fonctions distantes dans une boucle. Veuillez choisir et décommenter une fonction distante ci-dessous.
# L'exécution de plusieurs fonctions à la fois peut être lente si la caméra doit changer de mode
# à chaque exécution.

while True:
    exe_face_detection()  # Le visage doit être à environ 2ft de distance.
    # exe_qrcode_detection() # Placez le QRCode à environ 2ft de distance.
    # exe_all_qrcode_detection() # Placez le QRCode à environ 2ft de distance.
    # exe_apriltag_detection()
    # exe_all_apriltag_detection()
    # exe_datamatrix_detection() # Placez le Datamatrix à environ 2ft de distance.
    # exe_all_datamatrix_detection() # Placez le Datamatrix à environ 2ft de distance.
    # exe_barcode_detection() # Placez le code-barres à environ 2ft de distance.
    # exe_all_barcode_detection() # Placez le code-barres à environ 2ft de distance.
    # exe_color_detection()
    # exe_jpeg_snapshot()