`rpc` — rpc kütüphanesi¶

OpenMV Cam üzerindeki rpc modülü, OpenMV Cam’inizi başka bir mikrodenetleyiciye veya bilgisayara bağlamanıza ve OpenMV Cam’iniz üzerinde uzaktan python (veya prosedür) çağrıları yürütmenize olanak tanır. rpc modülü, OpenMV Cam’inizin başka bir mikrodenetleyici veya bilgisayar üzerinde uzaktan prosedür (veya python) çağrıları yürütebilmesini istiyorsanız tersini de yapmanıza izin verir.

Kütüphane Nasıl Kullanılır¶

UART üzerinden tek bir geri çağırma sunan minimal bir slave

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.

Slave’den bir JPEG çerçevesi isteyen eşleşen master

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")

Farklı bir taşıma katmanı kullanmak için rpc_uart_master / rpc_uart_slave yerine eşleşen can, i2c veya spi çiftini koyun.

Genel olarak, denetleyici cihazın rpc kütüphanesini kullanabilmesi için rpc kütüphanesini kullanarak bir arayüz nesnesi oluşturursunuz. Örneğin:

interface = rpc.rpc_uart_master(baudrate=115200)

Bu, bir rpc slave ile konuşmak için bir UART arayüzü oluşturur.

Arayüz oluşturulduktan sonra yapmanız gereken tek şey şudur:

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

Ve rpc kütüphanesi, o "remote_function_or_method_name" ifadesini slave üzerinde yürütmeye çalışacaktır. Uzak fonksiyon veya metot, boyutu 2^32-1 bayta kadar olabilen bytes_object_argument değerini alacaktır. Uzak metot yürütmeyi bitirdiğinde, boyutu yine 2^32-1 bayta kadar olabilen bir memory_view_object_result döndürecektir. Argüman ve yanıtın her ikisi de genel bayt konteynerleri olduğundan, rpc kütüphanesi aracılığıyla herhangi bir şeyi geçirebilir ve herhangi bir türde yanıt alabilirsiniz. Argümanları geçirmenin basit bir yolu, argümanı oluşturmak için struct.pack() ve diğer tarafta argümanı almak için struct.unpack() kullanmaktır. Yanıt için, diğer taraf sonuç olarak bir string nesnesi veya json string’i gönderebilir ve master bunu yorumlayabilir.

Hatalara gelince, var olmayan bir fonksiyon veya metot adını yürütmeye çalışırsanız rpc_master.call() metodu boş bir bytes() nesnesi döndürür. rpc kütüphanesi slave ile iletişim kurmayı başaramazsa rpc kütüphanesi None döndürür.

İşleri basit tutmak için rpc kütüphanesi master ve slave cihazları arasında bir bağlantı sürdürmez. rpc_master.call() metodu, slave’e bağlanmayı denemeyi, uzak fonksiyon veya metodun yürütülmesini başlatmayı ve sonucu almayı kapsar.

Şimdi, slave tarafında, master ile iletişim kurmak için bir rpc arayüzü oluşturmanız gerekir. Bu şöyle görünür:

interface = rpc.rpc_uart_slave(baudrate=115200)

Bu, bir rpc master ile konuşmak için UART arayüz katmanını oluşturacaktır.

Slave arayüzünü oluşturduktan sonra, arayüz nesnesiyle master’ın çağırabileceği geri çağırmaları kaydetmeniz gerekir:

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

interface.register_callback(remote_function_or_method_name)

Slave üzerinde istediğiniz kadar geri çağırma kaydedebilirsiniz. Son olarak, geri çağırmaları kaydetmeyi bitirdiğinizde yapmanız gereken tek şey şunu yürütmektir:

interface.loop()

Slave üzerinde rpc kütüphanesini başlatmak ve master’ı dinlemeye başlamak için. rpc_slave.loop() metodunun geri dönmediğini unutmayın.

class rpc – rpc temel sınıfı¶

rpc temel sınıfı, master ve slave arayüzlerini oluşturmak için rpc_master ve rpc_slave sınıfları tarafından yeniden uygulanır. Doğrudan kullanılması amaçlanmamıştır.

class rpc.rpc¶

Bir rpc nesnesi oluşturur. Doğrudan kullanılması amaçlanmamıştır.

get_bytes(buff: bytearray | memoryview, timeout_ms: int) → bytes | None¶: Taşımaya özgü alt sınıflar tarafından yeniden uygulanır. buff arabelleğini timeout_ms milisaniye içinde alttaki arayüzden gelen baytlarla doldurur. Zaman aşımında None döndürür.

put_bytes(data: bytes | memoryview, timeout_ms: int) → None¶: Taşımaya özgü alt sınıflar tarafından yeniden uygulanır. data verisini timeout_ms milisaniye içinde alttaki arayüz üzerinden gönderir.

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

Uzaktaki bir rpc.stream_writer‘dan bir yük akışı alır. Her iki taraf da senkronize olduktan sonra bir rpc_slave geri çağırması içinden (veya başarılı bir rpc_master.call sonrasında doğrudan) çağrılmalıdır.

call_back – alınan her yük için bir kez call_back(data) şeklinde çağrılan çağrılabilir nesne; burada data bir memoryview nesnesidir. Dönüş değeri yok sayılır.
queue_depth – yazarın okuyucuyu beklemeden önce gönderebileceği uçuştaki çerçeve sayısı. Daha yüksek değerler bellek pahasına iş hacmini artırır.
read_timeout_ms – her yük için beklenecek milisaniye süresi.

Herhangi bir hatada geri döner. İptal etmek için call_back içinde bir istisna fırlatın; uzak taraf zaman aşımına uğrayacaktır.

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

Uzaktaki bir rpc.stream_reader‘a bir yük akışı gönderir. Her iki taraf da senkronize olduktan sonra bir rpc_slave geri çağırması içinden (veya başarılı bir rpc_master.call sonrasında doğrudan) çağrılmalıdır.

call_back – argümansız çağrılan ve gönderilecek bir sonraki bytes veya memoryview yükünü döndüren çağrılabilir nesne.
write_timeout_ms – her yük gönderilirken beklenecek milisaniye süresi.

Herhangi bir hatada geri döner. İptal etmek için call_back içinde bir istisna fırlatın; uzak taraf zaman aşımına uğrayacaktır.

class rpc_master – rpc_master temel sınıfı¶

rpc_master bir temel sınıftır. Taşımaya özgü alt sınıflardan birini kullanın (rpc_can_master, rpc_i2c_master, rpc_spi_master, rpc_uart_master).

class rpc.rpc_master¶

Bir rpc_master nesnesi oluşturur. Doğrudan kullanılması amaçlanmamıştır.

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

Slave cihazda uzaktan bir çağrı yürütür.

name – yürütülecek uzak fonksiyon veya metodun string adı.
data – uzak fonksiyona argüman olarak geçirilen bytes benzeri nesne.
send_timeout – slave’e bağlanırken ve uzak fonksiyonun yürütülmesini başlatırken beklenecek milisaniye süresi. Master argümanı göndermeye başladığında bu artık geçerli değildir; kütüphane argüman aktarımı için 5 saniyeye kadar izin verir.
recv_timeout – slave’in bir yanıt döndürmeye başlaması için beklenecek milisaniye süresi. Master yanıtı almaya başladığında bu artık geçerli değildir; kütüphane yanıt aktarımı için 5 saniyeye kadar izin verir.

Başarı durumunda yanıtın bir memoryview nesnesini, uzak ad slave üzerinde mevcut değilse boş bir bytes() nesnesini veya iletişim hatasında None döndürür.

class rpc_slave – rpc_slave temel sınıfı¶

rpc_slave bir temel sınıftır. Taşımaya özgü alt sınıflardan birini kullanın (rpc_can_slave, rpc_i2c_slave, rpc_spi_slave, rpc_uart_slave).

class rpc.rpc_slave¶

Bir rpc_slave nesnesi oluşturur. Doğrudan kullanılması amaçlanmamıştır.

register_callback(cb: Callable[[memoryview], bytes | memoryview]) → None¶: Master’ın ada göre çağırabileceği bir geri çağırma kaydeder. cb, bir memoryview argümanı alan ve bir bytes benzeri nesne döndüren çağrılabilir bir nesnedir. Geri çağırmanın __name__ değeri arama anahtarı olarak kullanılır.

schedule_callback(cb: Callable[[], None]) → None¶: cb nesnesini (argümansız çağrılan bir çağrılabilir nesne), o anda çalışan rpc geri çağırması yanıtını master’a başarıyla döndürdükten hemen sonra bir kez yürütülmek üzere zamanlar. Bir rpc geri çağırması içinden çağrılmalıdır. Uzun süren işlerin veya rpc.get_bytes/rpc.put_bytes doğrudan geçiş aktarımlarının rpc işlemleri arasında çalışmasına olanak tanır. Tekrarlı yürütme gerekiyorsa her çağrımda yeniden kaydedin.

setup_loop_callback(cb: Callable[[], None]) → None¶: cb nesnesini (argümansız çağrılan bir çağrılabilir nesne), rpc_slave.loop işlevinin her yinelemesinde çağrılmak üzere kaydeder. rpc_slave.schedule_callback işlevinin aksine, bu geri çağırma kayıtlı kalır. Bloklamayan türde olmalıdır; çağrı oranı değişkendir.

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

rpc slave dağıtım döngüsünü çalıştırır. Bir geri çağırmadan fırlatılan istisna dışında geri dönmez.

recv_timeout – yeniden denemeden önce master’dan bir komut beklenecek milisaniye süresi.
send_timeout – almaya geri dönmeden önce master’ın yanıtı onaylaması için beklenecek milisaniye süresi.

class rpc_can_master – CAN Master Arayüzü¶

Başka bir rpc cihazını CAN üzerinden kontrol eder.

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

message_id – veri taşıma için kullanılan 11 bitlik CAN mesaj kimliği.
bit_rate – saniye başına bit cinsinden CAN bit hızı.
sample_point – Tseg1/Tseg2 örnekleme noktası yüzdesi (örn. 50.0, 62.5, 75, 87.5).
can_bus – CAN çevre birimi numarası.

Master ve slave message_id ve bit_rate değerleri eşleşmelidir. Bus 120 ohm ile sonlandırılmalıdır.

class rpc_can_slave – CAN Slave Arayüzü¶

Başka bir rpc cihazı tarafından CAN üzerinden kontrol edilir.

class rpc.rpc_can_slave(message_id: int = 0x7FF, bit_rate: int = 250000, sample_point: float = 75, can_bus: int = 2)¶: Argüman açıklamaları için rpc_can_master sınıfına bakın.

class rpc_i2c_master – I2C Master Arayüzü¶

Başka bir rpc cihazını I2C üzerinden kontrol eder.

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

slave_addr – slave cihazın 7 bitlik I2C adresi.
rate – Hz cinsinden I2C bus saat frekansı.
i2c_bus – I2C çevre birimi numarası.

Master ve slave adresleri eşleşmelidir. SCL ve SDA üzerinde harici pull-up dirençleri gereklidir ve her iki cihaz da ortak bir topraklamayı paylaşmalıdır.

class rpc_i2c_slave – I2C Slave Arayüzü¶

Başka bir rpc cihazı tarafından I2C üzerinden kontrol edilir.

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

slave_addr – bu slave’in yanıt verdiği 7 bitlik I2C adresi.
i2c_bus – I2C çevre birimi numarası.

class rpc_spi_master – SPI Master Arayüzü¶

Başka bir rpc cihazını SPI üzerinden kontrol eder.

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 – chip-select pin adı.
freq – Hz cinsinden SPI bus saat frekansı.
clk_polarity – boştaki saat seviyesi (0 veya 1).
clk_phase – veriyi ilk (0) veya ikinci (1) saat kenarında örnekler.
spi_bus – SPI çevre birimi numarası.

Master ve slave ayarları eşleşmelidir. CS, SCLK, MOSI, MISO’yu doğrudan bağlayın. Her iki cihaz da ortak bir topraklamayı paylaşmalıdır.

class rpc_spi_slave – SPI Slave Arayüzü¶

Başka bir rpc cihazı tarafından SPI üzerinden kontrol edilir.

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

cs_pin – chip-select giriş pin adı.
clk_polarity – boştaki saat seviyesi (0 veya 1).
clk_phase – veriyi ilk (0) veya ikinci (1) saat kenarında örnekler.
spi_bus – SPI çevre birimi numarası.

class rpc_uart_master – UART Master Arayüzü¶

Başka bir rpc cihazını Asenkron Seri (UART) üzerinden kontrol eder.

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

baudrate – seri baud hızı.
uart_port – UART çevre birimi numarası.

Master ve slave baud hızları eşleşmelidir. Master TX’i slave RX’e ve master RX’i slave TX’e bağlayın. Her iki cihaz da ortak bir topraklamayı paylaşmalıdır.

class rpc_uart_slave – UART Slave Arayüzü¶

Başka bir rpc cihazı tarafından Asenkron Seri (UART) üzerinden kontrol edilir.

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

baudrate – seri baud hızı.
uart_port – UART çevre birimi numarası.

rpc — rpc kütüphanesi¶