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

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, UART oder LAN/WLAN 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.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_slave(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.
#
# 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=7500000)

################################################################
# Callbacks
################################################################
img = None
img_ba = None
img_mv = None


# Setzt bei Aufruf pixformat und framesize, nimmt einen Snapshot auf
# und gibt anschließend die Form des Framebuffers zurück, in dem das Bild gespeichert wird.
#
# data besteht aus 4 Byte pixformat und 4 Byte framesize.
def raw_image_snapshot(data):
    global img, img_ba, img_mv
    pixformat, framesize = struct.unpack("<II", data)
    csi0.pixformat(pixformat)
    csi0.framesize(framesize)
    img = csi0.snapshot()
    img_ba = img.bytearray()
    img_mv = memoryview(img_ba)
    return struct.pack(
        "<IIII", csi0.width(), csi0.height(), csi0.pixformat(), img.size()
    )


def raw_image_read_cb():
    interface.put_bytes(img_ba, 5000)  # Timeout


# Daten aus dem Framebuffer anhand eines Offsets und einer Größe lesen.
# Wenn data leer ist, wird eine Übertragung geplant, nachdem der RPC-Aufruf abgeschlossen ist.
#
# data besteht aus 4 Byte Größe und 4 Byte Offset.
def raw_image_read(data):
    if not len(data):
        interface.schedule_callback(raw_image_read_cb)
        return bytes()
    else:
        offset, size = struct.unpack("<II", data)
        return img_mv[offset:offset + size]


# Callbacks registrieren.

interface.register_callback(raw_image_snapshot)
interface.register_callback(raw_image_read)

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

interface.loop()