`rpc` — rpc-kirjasto¶

OpenMV Camin rpc-moduuli mahdollistaa OpenMV Camin yhdistämisen toiseen mikrokontrolleriin tai tietokoneeseen ja etäkutsujen (remote python- tai procedure-kutsujen) suorittamisen OpenMV Camilla. rpc-moduuli mahdollistaa myös käänteisen toiminnan, jos haluat OpenMV Camin pystyvän suorittamaan etäproseduuri- (tai python-) kutsuja toisella mikrokontrollerilla tai tietokoneella.

Kirjaston käyttö¶

Minimaalinen slave, joka tuo käyttöön yhden takaisinkutsun UART:n kautta:

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.

Vastaava master, joka pyytää slavelta JPEG-kehystä:

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

Vaihda rpc_uart_master / rpc_uart_slave vastaavaan can-, i2c- tai spi-pariin käyttääksesi eri siirtotapaa.

Yleisesti ottaen, jotta ohjaava laite voi käyttää rpc-kirjastoa, luot rajapintaobjektin rpc-kirjastolla. Esimerkiksi:

interface = rpc.rpc_uart_master(baudrate=115200)

Tämä luo UART-rajapinnan, joka kommunikoi rpc-slaven kanssa.

Kun rajapinta on luotu, sinun tarvitsee vain tehdä:

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

Ja rpc-kirjasto yrittää suorittaa kyseisen "remote_function_or_method_name"-funktion slavella. Etäfunktio tai -metodi vastaanottaa bytes_object_argument-argumentin, jonka koko voi olla enintään 2^32-1 tavua. Kun etämetodi on suorittanut toimintansa, se palauttaa memory_view_object_result-tuloksen, joka voi myös olla kooltaan enintään 2^32-1 tavua. Koska sekä argumentti että vastaus ovat geneerisiä tavusäiliöitä, voit välittää mitä tahansa rpc-kirjaston kautta ja vastaanottaa minkä tahansa tyyppisen vastauksen. Yksinkertainen tapa välittää argumentteja on käyttää struct.pack()-funktiota argumentin luomiseen ja struct.unpack()-funktiota argumentin vastaanottamiseen toisella puolella. Vastauksena toinen puoli voi lähettää merkkijono-objektin tai json-merkkijonon tuloksena, jonka master voi sitten tulkita.

Virheiden osalta, jos yrität suorittaa olemattoman funktion tai metodin nimen, rpc_master.call()-metodi palauttaa tyhjän bytes()-objektin. Jos rpc-kirjasto ei onnistunut kommunikoimaan slaven kanssa, rpc-kirjasto palauttaa None.

Asioiden pitämiseksi yksinkertaisina rpc-kirjasto ei ylläpidä yhteyttä master- ja slave-laitteiden välillä. rpc_master.call()-metodi kapseloi yhteyden muodostamisen slaveen, etäfunktion tai -metodin suorituksen aloittamisen ja tuloksen hakemisen.

Slave-puolella sinun täytyy luoda rpc-rajapinta kommunikoidaksesi masterin kanssa. Tämä näyttää tältä:

interface = rpc.rpc_uart_slave(baudrate=115200)

Tämä luo UART-rajapintakerroksen, joka kommunikoi rpc-masterin kanssa.

Kun olet luonut slave-rajapinnan, sinun täytyy rekisteröidä takaisinkutsut, joita master voi kutsua rajapintaobjektin avulla:

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

interface.register_callback(remote_function_or_method_name)

Voit rekisteröidä slavelle niin monta takaisinkutsua kuin haluat. Lopuksi, kun olet rekisteröinyt takaisinkutsut, sinun tarvitsee vain suorittaa:

interface.loop()

Slavella tämä käynnistää rpc-kirjaston ja alkaa kuunnella masteria. Huomaa, että rpc_slave.loop()-metodi ei palaa.

class rpc – rpc-perusluokka¶

rpc-perusluokka toteutetaan uudelleen rpc_master- ja rpc_slave-luokissa master- ja slave-rajapintojen luomiseksi. Sitä ei ole tarkoitettu käytettäväksi suoraan.

class rpc.rpc¶

Luo rpc-objektin. Ei tarkoitettu käytettäväksi suoraan.

get_bytes(buff: bytearray | memoryview, timeout_ms: int) → bytes | None¶: Toteutetaan uudelleen siirtotapakohtaisissa aliluokissa. Täyttää buff-puskurin tavuilla taustalla olevasta rajapinnasta timeout_ms-millisekunnin sisällä. Palauttaa None aikakatkaisun yhteydessä.

put_bytes(data: bytes | memoryview, timeout_ms: int) → None¶: Toteutetaan uudelleen siirtotapakohtaisissa aliluokissa. Lähettää data-tiedot taustalla olevan rajapinnan kautta timeout_ms-millisekunnin sisällä.

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

Vastaanottaa hyötykuormien virran etäisestä rpc.stream_writer-objektista. Tulisi kutsua rpc_slave-takaisinkutsun sisältä (tai suoraan onnistuneen rpc_master.call-kutsun jälkeen), kun molemmat puolet ovat synkronoituneet.

call_back – kutsuttava objekti, jota kutsutaan kerran jokaista vastaanotettua hyötykuormaa kohden muodossa call_back(data), jossa data on memoryview. Paluuarvo jätetään huomiotta.
queue_depth – niiden lennossa olevien kehysten määrä, jotka kirjoittaja saa lähettää ennen kuin lukijaa odotetaan. Suuremmat arvot lisäävät läpäisykykyä muistin kustannuksella.
read_timeout_ms – hyötykuormaa kohden odotettavat millisekunnit.

Palaa minkä tahansa virheen yhteydessä. Peruuttaaksesi toiminnon nosta poikkeus call_back-funktion sisällä; etäpuoli aikakatkaistaan.

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

Lähettää hyötykuormien virran etäiseen rpc.stream_reader-objektiin. Tulisi kutsua rpc_slave-takaisinkutsun sisältä (tai suoraan onnistuneen rpc_master.call-kutsun jälkeen), kun molemmat puolet ovat synkronoituneet.

call_back – kutsuttava objekti, jota kutsutaan ilman argumentteja ja joka palauttaa seuraavan lähetettävän bytes- tai memoryview-hyötykuorman.
write_timeout_ms – kunkin hyötykuorman lähettämisessä odotettavat millisekunnit.

Palaa minkä tahansa virheen yhteydessä. Peruuttaaksesi toiminnon nosta poikkeus call_back-funktion sisällä; etäpuoli aikakatkaistaan.

class rpc_master – rpc_master-perusluokka¶

rpc_master on perusluokka. Käytä jotakin siirtotapakohtaisista aliluokista (rpc_can_master, rpc_i2c_master, rpc_spi_master, rpc_uart_master).

class rpc.rpc_master¶

Luo rpc_master-objektin. Ei tarkoitettu käytettäväksi suoraan.

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

Suorittaa etäkutsun slave-laitteella.

name – suoritettavan etäfunktion tai -metodin nimi merkkijonona.
data – bytes-tyyppinen objekti, joka välitetään argumenttina etäfunktiolle.
send_timeout – millisekunnit, jotka odotetaan slaveen yhdistettäessä ja etäfunktion suorituksen aloittamisessa. Kun master alkaa lähettää argumenttia, tämä ei enää päde; kirjasto sallii argumentin siirrolle enintään 5 sekuntia.
recv_timeout – millisekunnit, jotka odotetaan slaven aloittavan vastauksen palauttamisen. Kun master alkaa vastaanottaa vastausta, tämä ei enää päde; kirjasto sallii vastauksen siirrolle enintään 5 sekuntia.

Palauttaa onnistuessaan vastauksen memoryview-näkymän, tyhjän bytes()-objektin, jos etänimeä ei ole olemassa slavella, tai None kommunikaatiovirheen yhteydessä.

class rpc_slave – rpc_slave-perusluokka¶

rpc_slave on perusluokka. Käytä jotakin siirtotapakohtaisista aliluokista (rpc_can_slave, rpc_i2c_slave, rpc_spi_slave, rpc_uart_slave).

class rpc.rpc_slave¶

Luo rpc_slave-objektin. Ei tarkoitettu käytettäväksi suoraan.

register_callback(cb: Callable[[memoryview], bytes | memoryview]) → None¶: Rekisteröi takaisinkutsun, jonka master voi kutsua nimellä. cb on kutsuttava objekti, joka ottaa yhden memoryview-argumentin ja palauttaa bytes-tyyppisen objektin. Takaisinkutsun __name__ toimii hakuavaimena.

schedule_callback(cb: Callable[[], None]) → None¶: Ajastaa cb-objektin (kutsuttava objekti, joka ei ota argumentteja) suoritettavaksi kerran, välittömästi sen jälkeen kun parhaillaan suoritettava rpc-takaisinkutsu on onnistuneesti palauttanut vastauksensa masterille. On kutsuttava rpc-takaisinkutsun sisältä. Mahdollistaa pitkäkestoisen työn tai rpc.get_bytes/rpc.put_bytes-läpisiirtojen suorittamisen rpc-transaktioiden välissä. Rekisteröi uudelleen jokaisella kutsulla, jos toistuva suoritus on tarpeen.

setup_loop_callback(cb: Callable[[], None]) → None¶: Rekisteröi cb-objektin (kutsuttava objekti, joka ei ota argumentteja) kutsuttavaksi jokaisella rpc_slave.loop-silmukan kierroksella. Toisin kuin rpc_slave.schedule_callback, tämä takaisinkutsu pysyy rekisteröitynä. Sen on oltava ei-blokkaava; kutsutaajuus vaihtelee.

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

Suorittaa rpc-slaven käsittelysilmukan. Ei palaa muuten kuin takaisinkutsusta nostetun poikkeuksen kautta.

recv_timeout – millisekunnit, jotka odotetaan masterilta tulevaa komentoa ennen uudelleenyritystä.
send_timeout – millisekunnit, jotka odotetaan masterin kuittaavan vastauksen ennen vastaanottoon palaamista.

class rpc_can_master – CAN Master -rajapinta¶

Ohjaa toista rpc-laitetta CAN-väylän kautta.

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

message_id – 11-bittinen CAN-viestin id, jota käytetään tiedonsiirtoon.
bit_rate – CAN-bittinopeus bitteinä sekunnissa.
sample_point – Tseg1/Tseg2-näytteenottopisteen prosenttiosuus (esim. 50.0, 62.5, 75, 87.5).
can_bus – CAN-oheislaitteen numero.

Masterin ja slaven message_id- ja bit_rate-arvojen on täsmättävä. Väylä on päätettävä 120 ohmin vastuksella.

class rpc_can_slave – CAN Slave -rajapinta¶

Anna toisen rpc-laitteen ohjata CAN-väylän kautta.

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

class rpc_i2c_master – I2C Master -rajapinta¶

Ohjaa toista rpc-laitetta I2C:n kautta.

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

slave_addr – slave-laitteen 7-bittinen I2C-osoite.
rate – I2C-väylän kellotaajuus hertseinä.
i2c_bus – I2C-oheislaitteen numero.

Masterin ja slaven osoitteiden on täsmättävä. SCL- ja SDA-linjoilla vaaditaan ulkoiset ylösvetovastukset, ja molempien laitteiden on jaettava yhteinen maa.

class rpc_i2c_slave – I2C Slave -rajapinta¶

Anna toisen rpc-laitteen ohjata I2C:n kautta.

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

slave_addr – 7-bittinen I2C-osoite, johon tämä slave vastaa.
i2c_bus – I2C-oheislaitteen numero.

class rpc_spi_master – SPI Master -rajapinta¶

Ohjaa toista rpc-laitetta SPI:n kautta.

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-nastan nimi.
freq – SPI-väylän kellotaajuus hertseinä.
clk_polarity – kellon lepotaso (0 tai 1).
clk_phase – näytteistä tiedot ensimmäisellä (0) tai toisella (1) kelloreunalla.
spi_bus – SPI-oheislaitteen numero.

Masterin ja slaven asetusten on täsmättävä. Kytke CS, SCLK, MOSI ja MISO suoraan. Molempien laitteiden on jaettava yhteinen maa.

class rpc_spi_slave – SPI Slave -rajapinta¶

Anna toisen rpc-laitteen ohjata SPI:n kautta.

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-tulonastan nimi.
clk_polarity – kellon lepotaso (0 tai 1).
clk_phase – näytteistä tiedot ensimmäisellä (0) tai toisella (1) kelloreunalla.
spi_bus – SPI-oheislaitteen numero.

class rpc_uart_master – UART Master -rajapinta¶

Ohjaa toista rpc-laitetta asynkronisen sarjaliikenteen (UART) kautta.

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

baudrate – sarjaliikenteen siirtonopeus.
uart_port – UART-oheislaitteen numero.

Masterin ja slaven siirtonopeuksien on täsmättävä. Kytke masterin TX slaven RX:ään ja masterin RX slaven TX:ään. Molempien laitteiden on jaettava yhteinen maa.

class rpc_uart_slave – UART Slave -rajapinta¶

Anna toisen rpc-laitteen ohjata asynkronisen sarjaliikenteen (UART) kautta.

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

baudrate – sarjaliikenteen siirtonopeus.
uart_port – UART-oheislaitteen numero.

rpc — rpc-kirjasto¶