popular_features_as_the_controller_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
#
# Control remoto - Como dispositivo controlador
#
# Este script configura su OpenMV Cam para controlar remotamente otra OpenMV Cam usando la librería
# RPC. Este script puede ejecutarse en cualquier placa micropython que implemente el módulo pyb para
# controlar remotamente una OpenMV Cam.
#
# Este script está diseñado para emparejarse con "popular_features_as_the_remote_device.py".

import json
import rpc
import struct

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

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

# Descomente la siguiente línea para configurar su OpenMV Cam para controlar mediante 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. Normalmente 75%. (50.0, 62.5, 75, 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_master(message_id=0x7FF, bit_rate=250000, sample_point=75)

# Descomente la siguiente línea para configurar su OpenMV Cam para controlar mediante I2C.
#
# * slave_addr: dirección I2C.
# * rate - Frecuencia de reloj del bus 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_master(slave_addr=0x12, rate=100000)

# Descomente la siguiente línea para configurar su OpenMV Cam para controlar mediante SPI.
#
# * cs_pin: pin de selección de esclavo (Slave Select).
# * freq - Frecuencia de reloj del bus SPI.
# * 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_master(cs_pin="P3", freq=10000000, clk_polarity=1, clk_phase=0)

# Descomente la siguiente línea para configurar su OpenMV Cam para controlar mediante 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_master(baudrate=115200)

##############################################################
# Manejadores de funciones callback
##############################################################


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)  # umbrales genéricos para rojo
    # thresholds = (30, 100, -64, -8, -32, 32) # umbrales genéricos para verde
    # thresholds = (0, 30, 0, 64, -128, 0) # umbrales genéricos para azul
    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


# Ejecute funciones remotas en un bucle. Elija y descomente una función remota a continuación.
# Ejecutar varias a la vez puede resultar lento si la cámara necesita cambiar de modo
# en cada ejecución.

while True:
    exe_face_detection()  # La cara debe estar a unos 2 pies (2ft) de distancia.
    # exe_qrcode_detection() # Coloque el código QR a unos 2 pies (2ft) de distancia.
    # exe_all_qrcode_detection() # Coloque el código QR a unos 2 pies (2ft) de distancia.
    # exe_apriltag_detection()
    # exe_all_apriltag_detection()
    # exe_datamatrix_detection() # Coloque el Datamatrix a unos 2 pies (2ft) de distancia.
    # exe_all_datamatrix_detection() # Coloque el Datamatrix a unos 2 pies (2ft) de distancia.
    # exe_barcode_detection() # Coloque el código de barras a unos 2 pies (2ft) de distancia.
    # exe_all_barcode_detection() # Coloque el código de barras a unos 2 pies (2ft) de distancia.
    # exe_color_detection()
    # exe_jpeg_snapshot()