popular_features_as_the_controller_device.py

# Questo lavoro è concesso in licenza MIT.
# Copyright (c) 2013-2023 OpenMV LLC. Tutti i diritti riservati.
# https://github.com/openmv/openmv/blob/master/LICENSE
#
# Controllo remoto - Come dispositivo controllore
#
# Questo script configura la tua OpenMV Cam per controllare da remoto un'altra OpenMV Cam usando la libreria
# RPC. Questo script può essere eseguito su qualsiasi scheda micropython che implementa il modulo pyb per
# controllare da remoto una OpenMV Cam.
#
# Questo script è pensato per essere abbinato a "popular_features_as_the_remote_device.py".

import json
import rpc
import struct

# La libreria RPC sopra indicata è installata sulla tua OpenMV Cam e fornisce diverse classi per
# permettendo alla tua OpenMV Cam di controllare tramite CAN, I2C, SPI o UART.

##############################################################
# Scegli l'interfaccia tramite cui vuoi controllare una OpenMV Cam.
##############################################################

# Rimuovi il commento dalla riga seguente per configurare la tua OpenMV Cam per il controllo via CAN.
#
# * message_id - messaggio CAN da usare per il trasporto dati sul bus can (11 bit).
# * bit_rate - velocità di trasmissione (bit rate) CAN.
# * sample_point - rapporto Tseg1/Tseg2. Tipicamente 75%. (50.0, 62.5, 75, 87.5, ecc.)
#
# NOTA: gli id dei messaggi e i bit rate can di master e slave devono corrispondere. Collega il can high del master allo
# can high dello slave e il can low del master al can low dello slave. Il bus can deve essere terminato con 120 ohm.
#
# interface = rpc.rpc_can_master(message_id=0x7FF, bit_rate=250000, sample_point=75)

# Rimuovi il commento dalla riga seguente per configurare la tua OpenMV Cam per il controllo via I2C.
#
# * slave_addr - indirizzo I2C.
# * rate - frequenza di clock del bus I2C.
#
# NOTA: gli indirizzi di master e slave devono corrispondere. Collega lo scl del master allo scl dello slave e lo sda del master
# allo sda dello slave. Devi usare pull-up esterni. Infine, entrambi i dispositivi devono condividere una massa comune.
#
# interface = rpc.rpc_i2c_master(slave_addr=0x12, rate=100000)

# Rimuovi il commento dalla riga seguente per configurare la tua OpenMV Cam per il controllo via SPI.
#
# * cs_pin - pin di selezione dello slave (Slave Select).
# * freq - frequenza di clock del bus SPI.
# * clk_polarity - livello del clock a riposo (0 o 1).
# * clk_phase - campiona i dati sul primo (0) o secondo fronte (1) del clock.
#
# NOTA: le impostazioni di master e slave devono corrispondere. Collega CS, SCLK, MOSI, MISO a CS, SCLK, MOSI, MISO.
# Infine, entrambi i dispositivi devono condividere una massa comune.
#
# interface = rpc.rpc_spi_master(cs_pin="P3", freq=10000000, clk_polarity=1, clk_phase=0)

# Rimuovi il commento dalla riga seguente per configurare la tua OpenMV Cam per il controllo via UART.
#
# * baudrate - velocità di trasmissione seriale (baudrate).
#
# NOTA: i baudrate di master e slave devono corrispondere. Collega il tx del master all'rx dello slave e l'rx del master
# al tx dello slave. Infine, entrambi i dispositivi devono condividere una massa comune.
#
interface = rpc.rpc_uart_master(baudrate=115200)

##############################################################
# Gestori dei 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)  # soglie generiche per il rosso
    # thresholds = (30, 100, -64, -8, -32, 32) # soglie generiche per il verde
    # thresholds = (0, 30, 0, 64, -128, 0) # soglie generiche per il blu
    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


# Esegue le funzioni remote in un ciclo. Scegli e rimuovi il commento da una funzione remota qui sotto.
# Eseguirne più di una alla volta potrebbe essere lento se la fotocamera deve cambiare modalità
# a ogni esecuzione.

while True:
    exe_face_detection()  # Il volto dovrebbe trovarsi a circa 2 piedi (2ft) di distanza.
    # exe_qrcode_detection() # Posiziona il QRCode a circa 2 piedi (2ft) di distanza.
    # exe_all_qrcode_detection() # Posiziona il QRCode a circa 2 piedi (2ft) di distanza.
    # exe_apriltag_detection()
    # exe_all_apriltag_detection()
    # exe_datamatrix_detection() # Posiziona il Datamatrix a circa 2 piedi (2ft) di distanza.
    # exe_all_datamatrix_detection() # Posiziona il Datamatrix a circa 2 piedi (2ft) di distanza.
    # exe_barcode_detection() # Posiziona il Barcode a circa 2 piedi (2ft) di distanza.
    # exe_all_barcode_detection() # Posiziona il Barcode a circa 2 piedi (2ft) di distanza.
    # exe_color_detection()
    # exe_jpeg_snapshot()