`rpc` --- pustaka rpc¶

Modul rpc pada OpenMV Cam memungkinkan Anda menghubungkan OpenMV Cam ke mikrokontroler atau komputer lain dan mengeksekusi panggilan python jarak jauh (atau prosedur) pada OpenMV Cam Anda. Modul rpc juga memungkinkan kebalikannya jika Anda ingin OpenMV Cam dapat mengeksekusi panggilan prosedur jarak jauh (atau python) pada mikrokontroler atau komputer lain.

Cara Menggunakan Pustaka¶

Slave minimal yang mengekspos satu callback melalui UART:

import rpc
import csi

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

interface = rpc.rpc_uart_slave(baudrate=115200)

def snapshot(_):
    return csi0.snapshot().compress().bytearray()

interface.register_callback(snapshot)
interface.loop()  # Does not return.

Master yang sesuai yang meminta frame JPEG dari slave:

import rpc

interface = rpc.rpc_uart_master(baudrate=115200)

result = interface.call("snapshot")
if result is None:
    print("communication failed")
elif len(result) == 0:
    print("remote function not registered on the slave")
else:
    # result is a memoryview of the JPEG bytes returned by the slave.
    print("received", len(result), "bytes")

Ganti rpc_uart_master / rpc_uart_slave dengan pasangan can, i2c, atau spi yang sesuai untuk menggunakan transport yang berbeda.

Secara umum, agar perangkat kontroler dapat menggunakan pustaka rpc, Anda akan membuat objek antarmuka menggunakan pustaka rpc. Misalnya:

interface = rpc.rpc_uart_master(baudrate=115200)

Ini membuat antarmuka UART untuk berkomunikasi dengan slave rpc.

Setelah antarmuka dibuat, Anda hanya perlu melakukan:

memory_view_object_result = interface.call("remote_function_or_method_name", bytes_object_argument)

Dan pustaka rpc akan mencoba mengeksekusi "remote_function_or_method_name" tersebut pada slave. Fungsi atau metode jarak jauh akan menerima bytes_object_argument yang dapat berukuran hingga 2^32-1 byte. Setelah metode jarak jauh selesai dieksekusi, ia akan mengembalikan memory_view_object_result yang juga dapat berukuran hingga 2^32-1 byte. Karena argumen dan respons keduanya merupakan wadah byte generik, Anda dapat meneruskan apa saja melalui pustaka rpc dan menerima jenis respons apa pun. Cara sederhana untuk meneruskan argumen adalah menggunakan struct.pack() untuk membuat argumen dan struct.unpack() untuk menerima argumen di sisi lain. Untuk respons, sisi lain dapat mengirimkan objek string atau string json sebagai hasilnya yang kemudian dapat diinterpretasikan oleh master.

Mengenai kesalahan, jika Anda mencoba mengeksekusi nama fungsi atau metode yang tidak ada, metode rpc_master.call() akan mengembalikan objek bytes() kosong. Jika pustaka rpc gagal berkomunikasi dengan slave, pustaka rpc akan mengembalikan None.

Agar tetap sederhana, pustaka rpc tidak mempertahankan koneksi antara perangkat master dan slave. Metode rpc_master.call() merangkum upaya untuk terhubung ke slave, memulai eksekusi fungsi atau metode jarak jauh, dan mendapatkan hasilnya.

Sekarang, di sisi slave, Anda harus membuat antarmuka rpc untuk berkomunikasi dengan master. Tampilannya seperti ini:

interface = rpc.rpc_uart_slave(baudrate=115200)

Ini akan membuat lapisan antarmuka UART untuk berkomunikasi dengan master rpc.

Setelah Anda membuat antarmuka slave, Anda kemudian perlu mendaftarkan callback yang dapat dipanggil oleh master dengan objek antarmuka:

def remote_function_or_method_name(memoryview_object_argument):
    <lots of code>
    return bytes_object_result

interface.register_callback(remote_function_or_method_name)

Anda dapat mendaftarkan sebanyak mungkin callback pada slave. Terakhir, setelah Anda selesai mendaftarkan callback, Anda hanya perlu mengeksekusi:

interface.loop()

Pada slave untuk memulai pustaka rpc dan mulai mendengarkan master. Perhatikan bahwa metode rpc_slave.loop() tidak akan kembali.

class rpc -- kelas dasar rpc¶

Kelas dasar rpc diimplementasikan ulang oleh kelas rpc_master dan rpc_slave untuk membuat antarmuka master dan slave. Kelas ini tidak dimaksudkan untuk digunakan secara langsung.

class rpc.rpc¶

Membuat objek rpc. Tidak dimaksudkan untuk digunakan secara langsung.

get_bytes(buff: bytearray | memoryview, timeout_ms: int) → bytes | None¶: Diimplementasikan ulang oleh subkelas khusus transport. Mengisi buff dengan byte dari antarmuka yang mendasarinya dalam timeout_ms milidetik. Mengembalikan None saat timeout.

put_bytes(data: bytes | memoryview, timeout_ms: int) → None¶: Diimplementasikan ulang oleh subkelas khusus transport. Mengirim data melalui antarmuka yang mendasarinya dalam timeout_ms milidetik.

stream_reader(call_back: Callable[[memoryview], None], queue_depth: int = 1, read_timeout_ms: int = 5000) → None¶

Menerima aliran payload dari rpc.stream_writer jarak jauh. Harus dipanggil dari dalam callback rpc_slave (atau langsung setelah rpc_master.call yang berhasil) setelah kedua sisi tersinkronisasi.

call_back -- callable yang dipanggil sekali per payload yang diterima sebagai call_back(data) di mana data adalah sebuah memoryview. Nilai kembalian diabaikan.
queue_depth -- jumlah bingkai dalam penerbangan yang diizinkan untuk dikirim penulis sebelum menunggu pembaca. Nilai yang lebih tinggi meningkatkan throughput dengan mengorbankan memori.
read_timeout_ms -- milidetik untuk menunggu per payload.

Mengembalikan saat terjadi kesalahan apa pun. Untuk membatalkan, naikkan pengecualian di dalam call_back; sisi jarak jauh akan timeout.

stream_writer(call_back: Callable[[], bytes | memoryview], write_timeout_ms: int = 5000) → None¶

Mengirim aliran payload ke rpc.stream_reader jarak jauh. Harus dipanggil dari dalam callback rpc_slave (atau langsung setelah rpc_master.call yang berhasil) setelah kedua sisi tersinkronisasi.

call_back -- callable yang dipanggil tanpa argumen yang mengembalikan payload bytes atau memoryview berikutnya untuk dikirim.
write_timeout_ms -- milidetik untuk menunggu saat mengirim setiap payload.

Mengembalikan saat terjadi kesalahan apa pun. Untuk membatalkan, naikkan pengecualian di dalam call_back; sisi jarak jauh akan timeout.

class rpc_master -- kelas dasar rpc_master¶

rpc_master adalah kelas dasar. Gunakan salah satu subkelas khusus transport (rpc_can_master, rpc_i2c_master, rpc_spi_master, rpc_uart_master).

class rpc.rpc_master¶

Membuat objek rpc_master. Tidak dimaksudkan untuk digunakan secara langsung.

call(name: str, data: bytes = bytes(), send_timeout: int = 1000, recv_timeout: int = 1000) → memoryview | None¶

Mengeksekusi panggilan jarak jauh pada perangkat slave.

name -- nama string dari fungsi atau metode jarak jauh yang akan dieksekusi.
data -- objek seperti bytes yang diteruskan sebagai argumen ke fungsi jarak jauh.
send_timeout -- milidetik untuk menunggu saat menghubungkan ke slave dan memulai eksekusi fungsi jarak jauh. Setelah master mulai mengirim argumen, ini tidak lagi berlaku; pustaka mengizinkan hingga 5 detik untuk transfer argumen.
recv_timeout -- milidetik untuk menunggu slave mulai mengembalikan respons. Setelah master mulai menerima respons, ini tidak lagi berlaku; pustaka mengizinkan hingga 5 detik untuk transfer respons.

Mengembalikan memoryview dari respons jika berhasil, bytes() kosong jika nama jarak jauh tidak ada pada slave, atau None jika komunikasi gagal.

class rpc_slave -- kelas dasar rpc_slave¶

rpc_slave adalah kelas dasar. Gunakan salah satu subkelas khusus transport (rpc_can_slave, rpc_i2c_slave, rpc_spi_slave, rpc_uart_slave).

class rpc.rpc_slave¶

Membuat objek rpc_slave. Tidak dimaksudkan untuk digunakan secara langsung.

register_callback(cb: Callable[[memoryview], bytes | memoryview]) → None¶: Mendaftarkan callback yang dapat dipanggil oleh master berdasarkan nama. cb adalah callable yang mengambil satu argumen memoryview dan mengembalikan objek seperti bytes. __name__ callback digunakan sebagai kunci pencarian.

schedule_callback(cb: Callable[[], None]) → None¶: Menjadwalkan cb (callable yang tidak mengambil argumen) untuk dieksekusi sekali, segera setelah callback rpc yang sedang berjalan berhasil mengembalikan responsnya ke master. Harus dipanggil dari dalam callback rpc. Memungkinkan pekerjaan jangka panjang atau transfer cut-through rpc.get_bytes/rpc.put_bytes berjalan di antara transaksi rpc. Daftarkan ulang pada setiap pemanggilan jika eksekusi berulang diperlukan.

setup_loop_callback(cb: Callable[[], None]) → None¶: Mendaftarkan cb (callable yang tidak mengambil argumen) untuk dipanggil pada setiap iterasi rpc_slave.loop. Berbeda dengan rpc_slave.schedule_callback, callback ini tetap terdaftar. Harus non-blocking; laju pemanggilan bervariasi.

loop(recv_timeout: int = 1000, send_timeout: int = 1000) → None¶

Menjalankan loop pengiriman slave rpc. Tidak akan kembali kecuali ada pengecualian yang dimunculkan dari callback.

recv_timeout -- milidetik untuk menunggu perintah dari master sebelum mencoba lagi.
send_timeout -- milidetik untuk menunggu master mengakui respons sebelum kembali ke mode terima.

class rpc_can_master -- Antarmuka Master CAN¶

Kendalikan perangkat rpc lain melalui CAN.

class rpc.rpc_can_master(message_id: int = 0x7FF, bit_rate: int = 250000, sample_point: float = 75, can_bus: int = 2)¶

message_id -- ID pesan CAN 11-bit yang digunakan untuk transport data.
bit_rate -- laju bit CAN dalam bit per detik.
sample_point -- persentase titik sampel Tseg1/Tseg2 (misalnya 50.0, 62.5, 75, 87.5).
can_bus -- nomor periferal CAN.

message_id dan bit_rate master dan slave harus cocok. Bus harus diterminasi dengan 120 ohm.

class rpc_can_slave -- Antarmuka Slave CAN¶

Dikendalikan oleh perangkat rpc lain melalui CAN.

class rpc.rpc_can_slave(message_id: int = 0x7FF, bit_rate: int = 250000, sample_point: float = 75, can_bus: int = 2)¶: Lihat rpc_can_master untuk deskripsi argumen.

class rpc_i2c_master -- Antarmuka Master I2C¶

Kendalikan perangkat rpc lain melalui I2C.

class rpc.rpc_i2c_master(slave_addr: int = 0x12, rate: int = 100000, i2c_bus: int = 2)¶

slave_addr -- alamat I2C 7-bit dari perangkat slave.
rate -- frekuensi clock bus I2C dalam Hz.
i2c_bus -- nomor periferal I2C.

Alamat master dan slave harus cocok. Pull-up eksternal diperlukan pada SCL dan SDA, dan kedua perangkat harus berbagi ground yang sama.

class rpc_i2c_slave -- Antarmuka Slave I2C¶

Dikendalikan oleh perangkat rpc lain melalui I2C.

class rpc.rpc_i2c_slave(slave_addr: int = 0x12, i2c_bus: int = 2)¶

slave_addr -- alamat I2C 7-bit yang direspons oleh slave ini.
i2c_bus -- nomor periferal I2C.

class rpc_spi_master -- Antarmuka Master SPI¶

Kendalikan perangkat rpc lain melalui SPI.

class rpc.rpc_spi_master(cs_pin: str = 'P3', freq: int = 1000000, clk_polarity: int = 1, clk_phase: int = 0, spi_bus: int = 2)¶

cs_pin -- nama pin chip-select.
freq -- frekuensi clock bus SPI dalam Hz.
clk_polarity -- level clock saat idle (0 atau 1).
clk_phase -- sampel data pada tepi clock pertama (0) atau kedua (1).
spi_bus -- nomor periferal SPI.

Pengaturan master dan slave harus cocok. Hubungkan CS, SCLK, MOSI, MISO secara langsung. Kedua perangkat harus berbagi ground yang sama.

class rpc_spi_slave -- Antarmuka Slave SPI¶

Dikendalikan oleh perangkat rpc lain melalui SPI.

class rpc.rpc_spi_slave(cs_pin: str = 'P3', clk_polarity: int = 1, clk_phase: int = 0, spi_bus: int = 2)¶

cs_pin -- nama pin input chip-select.
clk_polarity -- level clock saat idle (0 atau 1).
clk_phase -- sampel data pada tepi clock pertama (0) atau kedua (1).
spi_bus -- nomor periferal SPI.

class rpc_uart_master -- Antarmuka Master UART¶

Kendalikan perangkat rpc lain melalui Serial Asinkron (UART).

class rpc.rpc_uart_master(baudrate: int = 9600, uart_port: int = 3)¶

baudrate -- laju baud serial.
uart_port -- nomor periferal UART.

Laju baud master dan slave harus cocok. Hubungkan TX master ke RX slave dan RX master ke TX slave. Kedua perangkat harus berbagi ground yang sama.

class rpc_uart_slave -- Antarmuka Slave UART¶

Dikendalikan oleh perangkat rpc lain melalui Serial Asinkron (UART).

class rpc.rpc_uart_slave(baudrate: int = 9600, uart_port: int = 3)¶

baudrate -- laju baud serial.
uart_port -- nomor periferal UART.

rpc --- pustaka rpc¶