popular_features_as_the_remote_device.py

# Dieses Werk ist unter der MIT-Lizenz lizenziert.
# Copyright (c) 2013-2023 OpenMV LLC. Alle Rechte vorbehalten.
# https://github.com/openmv/openmv/blob/master/LICENSE
#
# Fernsteuerung - Als Remote-Gerät
#
# Dieses Skript konfiguriert Ihre OpenMV Cam als Co-Prozessor, der ferngesteuert werden kann von
# einem anderen Mikrocontroller oder Computer wie einem Arduino, ESP8266/ESP32, RaspberryPi und
# sogar einer weiteren OpenMV Cam.
#
# Dieses Skript ist dafür ausgelegt, mit "popular_features_as_the_controller_device.py" zusammenzuarbeiten.

import image
import math
import rpc
import csi
import struct

csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.QVGA)
csi0.snapshot(time=2000)

# Die oben genannte RPC-Bibliothek ist auf Ihrer OpenMV Cam installiert und stellt mehrere Klassen bereit, um
# Ihre OpenMV Cam über CAN, I2C, SPI oder UART steuern zu können.

################################################################
# Wählen Sie die Schnittstelle, über die Sie Ihre OpenMV Cam steuern möchten.
################################################################

# Entfernen Sie das Kommentarzeichen der folgenden Zeile, um Ihre OpenMV Cam für die Steuerung über CAN einzurichten.
#
# * message_id - CAN-Nachricht, die für den Datentransport auf dem CAN-Bus verwendet wird (11-Bit).
# * bit_rate - CAN-Bitrate.
# * sample_point - Tseg1/Tseg2-Verhältnis. Typischerweise 75%. (50.0, 62.5, 75, 87.5, usw.)
#
# HINWEIS: Master- und Slave-Nachrichten-IDs sowie CAN-Bitraten müssen übereinstimmen. Verbinden Sie Master CAN-High mit Slave
# CAN-High und Master CAN-Low mit Slave CAN-Low. Der CAN-Bus muss mit 120 Ohm terminiert werden.
#
# interface = rpc.rpc_can_slave(message_id=0x7FF, bit_rate=250000, sample_point=75)

# Entfernen Sie das Kommentarzeichen der folgenden Zeile, um Ihre OpenMV Cam für die Steuerung über I2C einzurichten.
#
# * slave_addr - I2C-Adresse.
#
# HINWEIS: Master- und Slave-Adressen müssen übereinstimmen. Verbinden Sie Master SCL mit Slave SCL und Master SDA
# mit Slave SDA. Sie müssen externe Pull-ups verwenden. Schließlich müssen beide Geräte eine gemeinsame Masse haben.
#
# interface = rpc.rpc_i2c_slave(slave_addr=0x12)

# Entfernen Sie das Kommentarzeichen der folgenden Zeile, um Ihre OpenMV Cam für die Steuerung über SPI einzurichten.
#
# * cs_pin - Slave-Select-Pin.
# * clk_polarity - Ruhepegel des Takts (0 oder 1).
# * clk_phase - Daten bei der ersten (0) oder zweiten Flanke (1) des Takts abtasten.
#
# HINWEIS: Master- und Slave-Einstellungen müssen übereinstimmen. Verbinden Sie CS, SCLK, MOSI, MISO mit CS, SCLK, MOSI, MISO.
# Schließlich müssen beide Geräte eine gemeinsame Masse haben.
#
# interface = rpc.rpc_spi_slave(cs_pin="P3", clk_polarity=1, clk_phase=0)

# Entfernen Sie das Kommentarzeichen der folgenden Zeile, um Ihre OpenMV Cam für die Steuerung über UART einzurichten.
#
# * baudrate - Serielle Baudrate.
#
# HINWEIS: Master- und Slave-Baudraten müssen übereinstimmen. Verbinden Sie Master TX mit Slave RX und Master RX mit
# Slave TX. Schließlich müssen beide Geräte eine gemeinsame Masse haben.
#
interface = rpc.rpc_uart_slave(baudrate=115200)

################################################################
# Callbacks
################################################################

# Hilfsmethoden, die von den folgenden Callbacks verwendet werden.


def draw_detections(img, dects):
    for d in dects:
        c = d.corners
        c_len = len(c)
        for i in range(c_len):
            img.draw_line(c[(i + 0) % c_len] + c[(i + 1) % c_len], color=(0, 255, 0))
        img.draw_rectangle(d.rect, color=(255, 0, 0))


# Die Fernsteuerung funktioniert über Callback-Methoden, die das Steuergerät
# über das rpc-Modul auf diesem Gerät aufruft. Callbacks
# sind Funktionen, die ein bytes()-Objekt als Argument entgegennehmen
# und ein bytes()-Objekt als Ergebnis zurückgeben. Das rpc-Modul
# kümmert sich darum, die bytes()-Objekte über die Verbindung zu übertragen.
# bytes() kann bis zur maximalen Größe des MicroPython-int reichen.


# Gibt bei Aufruf x, y, w und h des größten Gesichts im Sichtfeld zurück.
#
# data wird nicht verwendet
def face_detection(data):
    csi0.pixformat(csi.GRAYSCALE)
    csi0.framesize(csi.QVGA)
    img = csi0.snapshot()
    faces = (
        img.gamma_corr(contrast=1.5)
        .find_features(image.HaarCascade("/rom/haarcascade_frontalface.cascade"))
    )
    if not faces:
        return bytes()  # Keine Erkennungen.
    for f in faces:
        img.draw_rectangle(f, color=(255, 255, 255))
    out_face = max(faces, key=lambda f: f[2] * f[3])
    return struct.pack("<HHHH", out_face[0], out_face[1], out_face[2], out_face[3])


# Gibt bei Aufruf die Payload-Zeichenfolge für den größten QR-Code zurück
# im Sichtfeld der OpenMV Cam.
#
# data wird nicht verwendet
def qrcode_detection(data):
    csi0.pixformat(csi.RGB565)
    csi0.framesize(csi.VGA)
    csi0.window((320, 240))
    img = csi0.snapshot()
    codes = img.find_qrcodes()
    if not codes:
        return bytes()  # Keine Erkennungen.
    draw_detections(img, codes)
    return max(codes, key=lambda c: c.w * c.h).payload.encode()


# Gibt bei Aufruf eine JSON-Liste von JSON-QR-Code-Objekten für alle sichtbaren QR-Codes zurück.
#
# data wird nicht verwendet
def all_qrcode_detection(data):
    csi0.pixformat(csi.RGB565)
    csi0.framesize(csi.VGA)
    csi0.window((320, 240))
    img = csi0.snapshot()
    codes = img.find_qrcodes()
    if not codes:
        return bytes()  # Keine Erkennungen.
    draw_detections(img, codes)
    return str(codes).encode()


# Gibt bei Aufruf den x/y-Schwerpunkt, die ID-Nummer und die Rotation des größten
# AprilTags im Sichtfeld der OpenMV Cam zurück.
#
# data wird nicht verwendet
def apriltag_detection(data):
    csi0.pixformat(csi.RGB565)
    csi0.framesize(csi.QQVGA)
    img = csi0.snapshot()
    tags = img.find_apriltags()
    if not tags:
        return bytes()  # Keine Erkennungen.
    draw_detections(img, tags)
    output_tag = max(tags, key=lambda t: t.w * t.h)
    return struct.pack(
        "<HHHH",
        output_tag.cx,
        output_tag.cy,
        output_tag.id,
        int(math.degrees(output_tag.rotation)),
    )


# Gibt bei Aufruf eine JSON-Liste von JSON-AprilTag-Objekten für alle sichtbaren AprilTags zurück.
#
# data wird nicht verwendet
def all_apriltag_detection(data):
    csi0.pixformat(csi.RGB565)
    csi0.framesize(csi.QQVGA)
    img = csi0.snapshot()
    tags = img.find_apriltags()
    if not tags:
        return bytes()  # Keine Erkennungen.
    draw_detections(img, tags)
    return str(tags).encode()


# Gibt bei Aufruf die Payload-Zeichenfolge für die größte Datamatrix zurück
# im Sichtfeld der OpenMV Cam.
#
# data wird nicht verwendet
def datamatrix_detection(data):
    csi0.pixformat(csi.RGB565)
    csi0.framesize(csi.VGA)
    csi0.window((320, 240))
    img = csi0.snapshot()
    codes = img.find_datamatrices()
    if not codes:
        return bytes()  # Keine Erkennungen.
    draw_detections(img, codes)
    return max(codes, key=lambda c: c.w * c.h).payload.encode()


# Gibt bei Aufruf eine JSON-Liste von JSON-Datamatrix-Objekten für alle sichtbaren Datamatrizen zurück.
#
# data wird nicht verwendet
def all_datamatrix_detection(data):
    csi0.pixformat(csi.RGB565)
    csi0.framesize(csi.VGA)
    csi0.window((320, 240))
    img = csi0.snapshot()
    codes = img.find_datamatrices()
    if not codes:
        return bytes()  # Keine Erkennungen.
    draw_detections(img, codes)
    return str(codes).encode()


# Gibt bei Aufruf die Payload-Zeichenfolge für den größten Barcode zurück
# im Sichtfeld der OpenMV Cam.
#
# data wird nicht verwendet
def barcode_detection(data):
    csi0.pixformat(csi.GRAYSCALE)
    csi0.framesize(csi.VGA)
    csi0.window((csi0.width(), csi0.height() // 8))
    img = csi0.snapshot()
    codes = img.find_barcodes()
    if not codes:
        return bytes()  # Keine Erkennungen.
    return max(codes, key=lambda c: c.w * c.h).payload.encode()


# Gibt bei Aufruf eine JSON-Liste von JSON-Barcode-Objekten für alle sichtbaren Barcodes zurück.
#
# data wird nicht verwendet
def all_barcode_detection(data):
    csi0.pixformat(csi.GRAYSCALE)
    csi0.framesize(csi.VGA)
    csi0.window((csi0.width(), csi0.height() // 8))
    img = csi0.snapshot()
    codes = img.find_barcodes()
    if not codes:
        return bytes()  # Keine Erkennungen.
    return str(codes).encode()


# Gibt bei Aufruf den x/y-Schwerpunkt des größten Blobs zurück
# im Sichtfeld der OpenMV Cam.
#
# data ist das 6-Byte-Tupel der Farbverfolgungs-Schwellenwerte L_MIN, L_MAX, A_MIN, A_MAX, B_MIN, B_MAX.
def color_detection(data):
    csi0.pixformat(csi.RGB565)
    csi0.framesize(csi.QVGA)
    thresholds = struct.unpack("<bbbbbb", data)
    img = csi0.snapshot()
    blobs = img.find_blobs(
        [thresholds], pixels_threshold=500, area_threshold=500, merge=True, margin=20
    )
    if not blobs:
        return bytes()  # Keine Erkennungen.
    for b in blobs:
        img.draw_detection(b, color1=(255, 0, 0), color2=(0, 255, 0))
    out_blob = max(blobs, key=lambda b: b.density)
    return struct.pack("<HH", out_blob.cx, out_blob.cy)


# Gibt bei Aufruf ein JPEG-komprimiertes Bild von der OpenMV
# Cam in einem einzigen RPC-Aufruf zurück.
#
# data wird nicht verwendet
def jpeg_snapshot(data):
    csi0.pixformat(csi.RGB565)
    csi0.framesize(csi.QVGA)
    img = csi0.snapshot()
    img.to_jpeg(quality=90)
    return img.bytearray()


# Callbacks registrieren.

interface.register_callback(face_detection)
interface.register_callback(qrcode_detection)
interface.register_callback(all_qrcode_detection)
interface.register_callback(apriltag_detection)
interface.register_callback(all_apriltag_detection)
interface.register_callback(datamatrix_detection)
interface.register_callback(all_datamatrix_detection)
interface.register_callback(barcode_detection)
interface.register_callback(all_barcode_detection)
interface.register_callback(color_detection)
interface.register_callback(jpeg_snapshot)

# Sobald alle Callbacks registriert sind, können wir mit der
# Verarbeitung der Remote-Ereignisse beginnen. interface.loop() kehrt nicht zurück.

interface.loop()