image_transfer_raw_as_the_controller_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
#
# Bildübertragung - Als Steuergerät
#
# Dieses Skript ist dafür gedacht, mit einer anderen OpenMV Cam zusammenzuarbeiten, auf der "image_transfer_raw_as_the_remote_device.py" läuft
#
# Dieses Skript zeigt, wie der Framebuffer von einer OpenMV Cam zu einer anderen übertragen wird.

import image
import omv
import rpc
import csi
import struct
import time

# Die oben genannte RPC-Bibliothek ist auf Ihrer OpenMV Cam installiert und stellt mehrere Klassen bereit, um
# sodass Ihre OpenMV Cam über CAN, I2C, SPI, UART oder LAN/WLAN steuern kann.

##############################################################
# Wählen Sie die Schnittstelle, über die Sie eine 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.0, 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_master(message_id=0x7FF, bit_rate=1000000, sample_point=75.0)

# Entfernen Sie das Kommentarzeichen der folgenden Zeile, um Ihre OpenMV Cam für die Steuerung über I2C einzurichten.
#
# * slave_addr - I2C-Adresse.
# * rate - I2C-Bus-Taktfrequenz.
#
# 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_master(slave_addr=0x12, rate=1000000)

# Entfernen Sie das Kommentarzeichen der folgenden Zeile, um Ihre OpenMV Cam für die Steuerung über SPI einzurichten.
#
# * cs_pin - Slave-Select-Pin.
# * freq - SPI-Bus-Taktfrequenz
# * 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_master(cs_pin="P3", freq=20000000, 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_master(baudrate=7500000)

##############################################################
# Callback-Handler
##############################################################


def get_frame_buffer_call_back(pixformat, framesize, cutthrough, silent):
    if not silent:
        print("Getting Remote Frame...")

    result = interface.call(
        "raw_image_snapshot", struct.pack("<II", pixformat, framesize)
    )
    if result is not None:
        w, h, pixformat, size = struct.unpack("<IIII", result)
        img = image.Image(w, h, pixformat, copy_to_fb=True)  # Geleerten Framebuffer allokieren.
        img_ba = img.bytearray()

        if cutthrough:
            # Schnelle Cut-Through-Datenübertragung ohne Fehlerprüfung.

            # Bevor die Cut-Through-Datenübertragung gestartet wird, müssen wir sowohl den Master als auch das
            # Slave-Gerät synchronisieren. Nach der Rückkehr sind beide Geräte synchron.
            result = interface.call("raw_image_read")
            if result is not None:
                # GET BYTES MUSS ALS NÄCHSTES SOFORT MIT GERINGER VERZÖGERUNG AUSGEFÜHRT WERDEN.

                # Alle Bilddaten in einer sehr großen Übertragung lesen.
                interface.get_bytes(img_ba, 5000)  # Timeout

        else:
            # Langsamere Datenübertragung mit Fehlerprüfung.

            # 32/8-KB-Blöcke übertragen.
            chunk_size = (1 << 15) if omv.board_type() == "H7" else (1 << 13)

            if not silent:
                print("Reading %d bytes..." % size)
            for i in range(0, size, chunk_size):
                ok = False
                for j in range(3):  # Bis zu 3 Mal versuchen.
                    result = interface.call(
                        "raw_image_read", struct.pack("<II", i, chunk_size)
                    )
                    if result is not None:
                        img_ba[i:i + chunk_size] = result  # Die Bilddaten schreiben.
                        if not silent:
                            print("%.2f%%" % ((i * 100) / size))
                        ok = True
                        break
                    if not silent:
                        print("Retrying... %d/2" % (j + 1))
                if not ok:
                    if not silent:
                        print("Error!")
                    return None

        return img

    else:
        if not silent:
            print("Failed to get Remote Frame!")

    return None


clock = time.clock()
while True:
    clock.tick()

    # Sie können pixformat und framesize des vom Remote-Gerät übertragenen Bildes ändern,
    # indem Sie die folgenden Argumente anpassen.
    #
    # Wenn cutthrough auf False steht, wird das Bild über die RPC-Bibliothek mit CRC- und
    # Wiederholungsschutz für alle übertragenen Daten transferiert. Für eine schnellere Datenübertragung setzen Sie cutthrough auf True, sodass
    # get_bytes() und put_bytes() nach Abschluss eines RPC-Aufrufs aufgerufen werden, um Daten
    # schneller von einem Bildpuffer zum anderen zu übertragen. Hinweis: Dies funktioniert, weil beide Geräte, sobald ein RPC-Aufruf
    # erfolgreich abgeschlossen ist, vollständig synchronisiert sind.
    #
    img = get_frame_buffer_call_back(
        csi.RGB565, csi.QQVGA, cutthrough=True, silent=True
    )
    if img is not None:
        pass  # Hier können Sie das Bild verarbeiten.

    print(clock.fps())