image_transfer_raw_as_the_controller_device.py

# Эта работа лицензирована по лицензии MIT.
# Copyright (c) 2013-2023 OpenMV LLC. All rights reserved.
# https://github.com/openmv/openmv/blob/master/LICENSE
#
# Передача изображения — в роли устройства-контроллера
#
# Этот скрипт предназначен для работы в паре с другой камерой OpenMV Cam, на которой выполняется "image_transfer_raw_as_the_remote_device.py"
#
# Этот скрипт показывает, как передать буфер кадра с одной камеры OpenMV Cam на другую.

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

# Указанная выше библиотека RPC установлена на вашей камере OpenMV Cam и предоставляет несколько классов,
# позволяющих управлять вашей камерой OpenMV Cam по CAN, I2C, SPI, UART или LAN/WLAN.

##############################################################
# Выберите интерфейс, через который вы хотите управлять камерой OpenMV Cam.
##############################################################

# Раскомментируйте строку ниже, чтобы настроить OpenMV Cam для управления через CAN.
#
# * message_id — идентификатор CAN-сообщения для передачи данных по шине CAN (11 бит).
# * bit_rate — скорость передачи по CAN.
# * sample_point — соотношение Tseg1/Tseg2. Обычно 75%. (50.0, 62.5, 75.0, 87.5 и т. д.)
#
# ПРИМЕЧАНИЕ: идентификаторы сообщений и скорости CAN у ведущего и ведомого устройств должны совпадать. Соедините CAN high ведущего с
# CAN high ведомого, а CAN low ведущего — с CAN low ведомого. Шина CAN должна быть терминирована резисторами 120 Ом.
#
# interface = rpc.rpc_can_master(message_id=0x7FF, bit_rate=1000000, sample_point=75.0)

# Раскомментируйте строку ниже, чтобы настроить OpenMV Cam для управления через I2C.
#
# * slave_addr — адрес I2C.
# * rate — частота тактирования шины I2C.
#
# ПРИМЕЧАНИЕ: адреса ведущего и ведомого устройств должны совпадать. Соедините scl ведущего со scl ведомого, а sda ведущего
# со sda ведомого. Необходимо использовать внешние подтягивающие резисторы. Наконец, оба устройства должны иметь общую землю.
#
# interface = rpc.rpc_i2c_master(slave_addr=0x12, rate=1000000)

# Раскомментируйте строку ниже, чтобы настроить OpenMV Cam для управления через SPI.
#
# * cs_pin — вывод выбора ведомого устройства (Slave Select).
# * freq — частота тактирования шины SPI
# * clk_polarity — уровень тактового сигнала в состоянии простоя (0 или 1).
# * clk_phase — выборка данных по первому (0) или второму (1) фронту тактового сигнала.
#
# ПРИМЕЧАНИЕ: настройки ведущего и ведомого устройств должны совпадать. Соедините CS, SCLK, MOSI, MISO с CS, SCLK, MOSI, MISO соответственно.
# Наконец, оба устройства должны иметь общую землю.
#
interface = rpc.rpc_spi_master(cs_pin="P3", freq=20000000, clk_polarity=1, clk_phase=0)

# Раскомментируйте строку ниже, чтобы настроить OpenMV Cam для управления через UART.
#
# * baudrate — скорость передачи последовательного порта.
#
# ПРИМЕЧАНИЕ: скорости передачи ведущего и ведомого устройств должны совпадать. Соедините tx ведущего с rx ведомого, а rx ведущего —
# с tx ведомого. Наконец, оба устройства должны иметь общую землю.
#
# interface = rpc.rpc_uart_master(baudrate=7500000)

##############################################################
# Обработчики обратного вызова
##############################################################


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)  # Выделить очищенный буфер кадра.
        img_ba = img.bytearray()

        if cutthrough:
            # Быстрая сквозная передача данных без проверки ошибок.

            # Перед началом сквозной передачи данных необходимо синхронизировать master и
            # slave-устройство. После возврата оба устройства синхронизированы.
            result = interface.call("raw_image_read")
            if result is not None:
                # GET BYTES ДОЛЖНА ВЫПОЛНИТЬСЯ СЛЕДУЮЩЕЙ НЕМЕДЛЕННО, С МИНИМАЛЬНОЙ ЗАДЕРЖКОЙ.

                # Считать все данные изображения за одну очень большую передачу.
                interface.get_bytes(img_ba, 5000)  # тайм-аут

        else:
            # Более медленная передача данных с проверкой ошибок.

            # Передавать блоками по 32/8 КБ.
            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):  # Пробовать до 3 раз.
                    result = interface.call(
                        "raw_image_read", struct.pack("<II", i, chunk_size)
                    )
                    if result is not None:
                        img_ba[i:i + chunk_size] = result  # Записать данные изображения.
                        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()

    # Вы можете изменить pixformat и framesize изображения, передаваемого с удалённого устройства,
    # изменив приведённые ниже аргументы.
    #
    # Если cutthrough равно False, изображение будет передаваться через библиотеку RPC с CRC и
    # защитой повторных попыток для всех передаваемых данных. Для более быстрой передачи данных установите cutthrough в True, чтобы
    # get_bytes() и put_bytes() вызывались после завершения RPC-вызова для передачи данных
    # быстрее из одного буфера изображения в другой. Примечание: это работает, потому что после завершения RPC-вызова
    # оба устройства, master и slave, полностью синхронизированы.
    #
    img = get_frame_buffer_call_back(
        csi.RGB565, csi.QQVGA, cutthrough=True, silent=True
    )
    if img is not None:
        pass  # Здесь вы можете обработать изображение.

    print(clock.fps())