popular_features_as_the_controller_device.py

# Este trabalho está licenciado sob a licença MIT.
# Copyright (c) 2013-2023 OpenMV LLC. Todos os direitos reservados.
# https://github.com/openmv/openmv/blob/master/LICENSE
#
# Controle remoto - Como o dispositivo controlador
#
# Este script configura a sua OpenMV Cam para controlar remotamente outra OpenMV Cam usando a biblioteca
# RPC. Este script pode ser executado em qualquer placa micropython que implemente o módulo pyb para
# controlar remotamente uma OpenMV Cam.
#
# Este script foi projetado para ser combinado com "popular_features_as_the_remote_device.py".

import json
import rpc
import struct

# A biblioteca RPC acima está instalada na sua OpenMV Cam e fornece diversas classes para
# permitindo que sua OpenMV Cam controle via CAN, I2C, SPI ou UART.

##############################################################
# Escolha a interface pela qual deseja controlar uma OpenMV Cam.
##############################################################

# Descomente a linha abaixo para configurar sua OpenMV Cam para controlar via CAN.
#
# * message_id - Mensagem CAN usada para transporte de dados no barramento CAN (11 bits).
# * bit_rate - Taxa de bits do CAN.
# * sample_point - Proporção Tseg1/Tseg2. Tipicamente 75%. (50.0, 62.5, 75, 87.5, etc.)
#
# NOTA: Os message ids e as taxas de bits do CAN do mestre e do escravo devem coincidir. Conecte o can high do mestre ao
# can high do escravo e o can low do mestre ao can low do escravo. O barramento CAN deve ser terminado com 120 ohms.
#
# interface = rpc.rpc_can_master(message_id=0x7FF, bit_rate=250000, sample_point=75)

# Descomente a linha abaixo para configurar sua OpenMV Cam para controlar via I2C.
#
# * slave_addr - Endereço I2C.
# * rate - Frequência do clock do barramento I2C.
#
# NOTA: Os endereços do mestre e do escravo devem coincidir. Conecte o scl do mestre ao scl do escravo e o sda do mestre
# ao sda do escravo. É necessário usar pull-ups externos. Por fim, ambos os dispositivos devem compartilhar um ground.
#
# interface = rpc.rpc_i2c_master(slave_addr=0x12, rate=100000)

# Descomente a linha abaixo para configurar sua OpenMV Cam para controlar via SPI.
#
# * cs_pin - Pino de seleção do escravo (Slave Select).
# * freq - Frequência do clock do barramento SPI.
# * clk_polarity - Nível do clock em repouso (0 ou 1).
# * clk_phase - Amostra dados na primeira (0) ou segunda borda (1) do clock.
#
# NOTA: As configurações do mestre e do escravo devem coincidir. Conecte CS, SCLK, MOSI, MISO a CS, SCLK, MOSI, MISO.
# Por fim, ambos os dispositivos devem compartilhar um ground comum.
#
# interface = rpc.rpc_spi_master(cs_pin="P3", freq=10000000, clk_polarity=1, clk_phase=0)

# Descomente a linha abaixo para configurar sua OpenMV Cam para controlar via UART.
#
# * baudrate - Taxa de transmissão serial.
#
# NOTA: As taxas de baud do mestre e do escravo devem coincidir. Conecte o tx do mestre ao rx do escravo e o rx do mestre ao
# tx do escravo. Por fim, ambos os dispositivos devem compartilhar um ground comum.
#
interface = rpc.rpc_uart_master(baudrate=115200)

##############################################################
# Manipuladores de Call Back
##############################################################


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


# Executar funções remotas em um loop. Escolha e descomente uma função remota abaixo.
# Executar várias ao mesmo tempo pode ser lento se a câmera precisar mudar de modo
# a cada execução.

while True:
    exe_face_detection()  # O rosto deve estar a cerca de 2ft de distância.
    # exe_qrcode_detection() # Coloque o QRCode a cerca de 2ft de distância.
    # exe_all_qrcode_detection() # Coloque o QRCode a cerca de 2ft de distância.
    # exe_apriltag_detection()
    # exe_all_apriltag_detection()
    # exe_datamatrix_detection() # Coloque o Datamatrix a cerca de 2ft de distância.
    # exe_all_datamatrix_detection() # Coloque o Datamatrix a cerca de 2ft de distância.
    # exe_barcode_detection() # Coloque o código de barras a cerca de 2ft de distância.
    # exe_all_barcode_detection() # Coloque o código de barras a cerca de 2ft de distância.
    # exe_color_detection()
    # exe_jpeg_snapshot()