`aioble` — Asynkroninen BLE¶

aioble on korkean tason asyncio-ystävällinen kääre bluetooth -moduulin ympärille. Se tarjoaa selkeät korutiinit skannaukseen, yhdistämiseen, mainostamiseen, GATT-palveluihin ja L2CAP-kanaviin.

Kaikki etäoperaatiot (connect, disconnect, asiakkaan luku/kirjoitus, palvelimen indicate, l2cap recv/send, pair) ovat odotettavissa (awaitable) ja tukevat aikakatkaisuja.

Tuetut roolit:

Broadcaster (mainostaja) — luo mainos- ja skannausvastauspayloadit yleisille kentille, jakaa payloadin automaattisesti mainos- ja skannausvastauksen kesken, mainostaa rajattomasti tai kiinteän ajan.
Peripheral (oheislaite) — odota yhteyttä centralilta, odota MTU-vaihtoa.
Observer (skanneri) — passiivinen ja aktiivinen skannaus, yhdistä saman laitteen mainos- ja skannausvastauspayloadit, jäsennä yleiset kentät mainospayloadeista.
Central — yhdistä oheislaitteeseen, käynnistä MTU-vaihto.
GATT-asiakas — löydä palvelut / ominaisuudet / kuvaajat (valinnaisesti UUID:n perusteella); lue / kirjoita / write-with-response ominaisuuksiin ja kuvaajiin; tilaa ilmoitukset (notifications) ja osoitukset (indications) (CCCD:n kautta); odota ilmoituksia ja osoituksia.
GATT-palvelin — rekisteröi palvelut / ominaisuudet / kuvaajat; odota kirjoituksia ominaisuuksiin ja kuvaajiin; sieppaa lukupyyntöjä; lähetä ilmoituksia ja osoituksia (ja odota vastausta).
L2CAP — hyväksy ja yhdistä L2CAP-yhteyssuuntautuneet kanavat, hallitse kanavan vuonohjausta.
Tietoturva — JSON-pohjainen avainten/salaisuuksien hallinta, käynnistä paritus, kysele salaus- / todennustilaa.

Esimerkit¶

Skannaa lähistöllä olevat BLE-laitteet ja tulosta jokainen sitä mukaa kun se havaitaan:

import aioble
import asyncio

async def find_devices():
    async with aioble.scan(duration_ms=5000, active=True) as scanner:
        async for result in scanner:
            print(result.device.addr_hex(), result.rssi, result.name())

asyncio.run(find_devices())

Yhdistä centralina oheislaitteeseen, joka mainostaa Heart Rate -palvelua, ja tilaa sen mittausilmoitukset:

import aioble
import asyncio
import bluetooth

_HR_SERVICE = bluetooth.UUID(0x180D)
_HR_MEASUREMENT = bluetooth.UUID(0x2A37)

async def connect_and_read():
    device = None
    async with aioble.scan(duration_ms=5000, active=True) as scanner:
        async for result in scanner:
            if _HR_SERVICE in result.services():
                device = result.device
                break
    if device is None:
        return

    async with await device.connect() as conn:
        service = await conn.service(_HR_SERVICE)
        char = await service.characteristic(_HR_MEASUREMENT)
        await char.subscribe(notify=True)
        while True:
            data = await char.notified()
            print("notify:", data)

asyncio.run(connect_and_read())

Toimi oheislaitteena: rekisteröi GATT-palvelu, mainosta sitä ja työnnä ilmoituksia kaikille yhdistäville:

import aioble
import asyncio
import bluetooth
import struct

_ENV_SERVICE = bluetooth.UUID(0x181A)
_TEMP_CHAR = bluetooth.UUID(0x2A6E)

def encode_temperature(deg_c):
    # Bluetooth Temperature (0x2A6E) is sint16 little-endian, 0.01 degC units.
    return struct.pack("<h", round(deg_c * 100))

service = aioble.Service(_ENV_SERVICE)
temp_char = aioble.Characteristic(service, _TEMP_CHAR, read=True, notify=True)
aioble.register_services(service)

async def peripheral_task():
    while True:
        connection = await aioble.advertise(
            interval_us=250000,
            name="openmv-sensor",
            services=[_ENV_SERVICE],
            appearance=0x0300,
        )
        print("connected:", connection.device.addr_hex())
        async with connection:
            while connection.is_connected():
                temp_char.write(encode_temperature(23.68), send_update=True)
                await asyncio.sleep(1)

asyncio.run(peripheral_task())

Moduulitason funktiot¶

aioble.config(*args, **kwargs) → Any¶

Välittää kutsun eteenpäin metodille bluetooth.BLE.config() varmistaen ensin, että BLE-radio on aktiivinen.

args: Valinnainen yksittäinen parametrin nimi kyselyä varten.
kwargs: Avainsana-argumentit asetusarvojen määrittämiseen.

aioble.stop() → None¶: Poista taustalla oleva BLE-radio käytöstä ja suorita kaikki rekisteröidyt alimoduulien sammutuskäsittelijät. Tämän kutsumisen jälkeen skannerit, mainostajat, yhteydet ja L2CAP-kanavat puretaan kaikki.

aioble.scan(duration_ms: int, interval_us: int | None = None, window_us: int | None = None, active: bool = False) → scan¶

Palauttaa scan -asynkronisen kontekstinhallitsijan / asynkronisen iteraattorin, joka tuottaa ScanResult -ilmentymän jokaiselle löydetylle yksilölliselle laitteelle (tai jokaiselle tunnetun laitteen uudelle mainosdatan osalle).

duration_ms: Kuinka kauan skannataan, millisekunteina. Anna 0 skannataksesi rajattomasti, kunnes kontekstinhallitsija päättyy.
interval_us: Skannausväli mikrosekunteina. Oletusarvo on 1 280 000.
window_us: Skannausikkuna mikrosekunteina (täytyy olla pienempi tai yhtä suuri kuin interval_us). Oletusarvo on 11 250.
active: Jos True, suorita aktiivinen skannaus (pyydä skannausvastausdataa). Oletusarvo on False.

aioble.advertise(interval_us: int, adv_data: bytes | None = None, resp_data: bytes | None = None, connectable: bool = True, limited_disc: bool = False, br_edr: bool = False, name: str | None = None, services: list | None = None, appearance: int = 0, manufacturer: tuple | None = None, timeout_ms: int | None = None) → DeviceConnection¶

Asynkroninen korutiini, joka aloittaa mainostamisen ja odottaa saapuvaa central-yhteyttä. Palauttaa yhdistettyä centralia edustavan DeviceConnection -objektin tai nostaa asyncio.TimeoutError -poikkeuksen aikakatkaisun yhteydessä.

interval_us: Mainosväli mikrosekunteina.
adv_data: Raaka mainospayload. Jos asettamatta, adv_data rakennetaan jäljellä olevista avainsana-argumenteista.
resp_data: Raaka skannausvastauspayload. Täytetään automaattisesti adv_data -payloadin ylivuodolla tarvittaessa.
connectable: Jos True, tämä on yhdistettävissä oleva mainos.
limited_disc: Käytä limited-discoverable-lippua yleisen sijaan.
br_edr: Aseta BR/EDR-tuetun lippu.
name: Valinnainen täydellinen paikallinen nimi upotettavaksi.
services: Iteroitava joukko bluetooth.UUID -arvoja mainostettavaksi.
appearance: 16-bittinen appearance-arvo (katso Bluetoothin määritetyt numerot).
manufacturer: Monikko (company_id, data_bytes) mainostettavaksi valmistajakohtaisena datana.
timeout_ms: Lopeta mainostaminen tämän millisekuntimäärän jälkeen ilman yhteyttä. None tarkoittaa mainostamista kunnes yhteys muodostuu.

aioble.register_services(*services: Service) → None¶

Rekisteröi yksi tai useampi Service -objekti (ja niiden ominaisuudet ja kuvaajat) GATT-palvelimelle. Täytyy kutsua kerran ennen advertise -toiminnon aloittamista. Myöhemmät kutsut korvaavat aiemman rekisteröinnin.

services: Yksi tai useampi Service -ilmentymä.

Moduulitason vakiot¶

aioble.ADDR_PUBLIC¶: Julkinen BLE-laiteosoitteen tyyppi (0).

aioble.ADDR_RANDOM¶: Satunnainen BLE-laiteosoitteen tyyppi (1).

Poikkeukset¶

exception aioble.GattError¶: Nostetaan, kun etä-GATT-operaatio (luku / kirjoitus / indicate) päättyy nollasta poikkeavalla tilalla. Tilakoodi on saatavilla _status -attribuutista.

exception aioble.DeviceDisconnectedError¶: Nostetaan asynkronisen operaation sisällä (esim. read, write, notified), kun taustalla oleva yhteys katkeaa odotuksen aikana.

exception aioble.L2CAPDisconnectedError¶: Nostetaan, kun L2CAP-kanavan send/recv/flush-operaatiota yritetään katkenneella kanavalla (tai sellaisen keskeyttämänä).

exception aioble.L2CAPConnectionError¶: Nostetaan metodista DeviceConnection.l2cap_connect, kun kanavan muodostaminen epäonnistuu. Bluetoothin tilakoodi on ensimmäinen argumentti.

Luokat¶

class aioble.Device(addr_type: int, addr: bytes | str)¶

Edustaa etä-BLE-laitetta osoitteen perusteella. Kaksi Device -ilmentymää ovat yhtä suuret, jos sekä addr_type että addr täsmäävät. Käytetään kahvana yhteyksien muodostamiseen.

addr_type: Joko ADDR_PUBLIC tai ADDR_RANDOM.
addr: Kuusitavuinen osoite bytes -muodossa tai kaksoispisteillä eroteltuna heksamerkkijonona (esim. "aa:bb:cc:dd:ee:ff").

addr_type¶: Osoitetyyppi, jolla laite muodostettiin.

addr¶: Raaka kuusitavuinen laiteosoite.

addr_hex() → str¶: Palauta osoite muotoiltuna kaksoispisteillä eroteltuna heksamerkkijonona.

connect(timeout_ms: int = 10000, scan_duration_ms: int | None = None, min_conn_interval_us: int | None = None, max_conn_interval_us: int | None = None) → Awaitable[DeviceConnection]¶

Asynkroninen. Käynnistä GAP-yhteys tähän laitteeseen ja palauta syntyvä DeviceConnection. Peruuttaa kaikki käynnissä olevat skannaukset.

timeout_ms: Kuinka kauan odotetaan yhteyden muodostumista.
scan_duration_ms: Alustava skannauskesto ennen yhdistämistä (ohjainkohtainen).
min_conn_interval_us / max_conn_interval_us: Valinnaiset yhteysvälin rajat mikrosekunteina.

class aioble.DeviceConnection¶

Aktiivinen GAP-yhteys Device -laitteeseen. Palauttaa Device.connect() tai advertise. Tukee käyttöä async with -kontekstinhallitsijana, joka katkaisee yhteyden automaattisesti poistuttaessa.

Älä muodosta suoraan.

device¶: Taustalla oleva Device.

encrypted¶: True kun linkki on salattu (esim. parituksen jälkeen).

authenticated¶: True jos linkki todennettiin (MITM-suojattu paritus).

bonded¶: True jos paritus tuotti sidonta-avaimia (bonding keys).

key_size¶: Neuvoteltu salausavaimen koko tavuina tai False jos ei salattu.

mtu¶: Neuvoteltu ATT MTU exchange_mtu -toiminnon jälkeen tai None kunnes asetettu.

is_connected() → bool¶: Palauta, onko yhteys edelleen aktiivinen.

disconnect(timeout_ms: int = 2000) → Awaitable[None]¶

Asynkroninen. Katkaise yhteys ja odota katkaisun IRQ:ta.

timeout_ms: Maksimiaika katkaisun odottamiseen.

disconnected(timeout_ms: int | None = None, disconnect: bool = False) → Awaitable[None]¶

Asynkroninen. Odota, että jompikumpi osapuoli päättää yhteyden. Jos disconnect on True, se katkaisee yhteyden ensin aktiivisesti.

timeout_ms: Maksimiaika odottamiseen. None tarkoittaa loputonta odotusta.
disconnect: Jos True, käynnistä yhteyden katkaisu.

timeout(timeout_ms: int | None) → DeviceTimeout¶

Palauta kontekstinhallitsija, joka peruuttaa rungon, jos joko aikakatkaisu kuluu (nostaen asyncio.TimeoutError) tai laitteen yhteys katkeaa (nostaen DeviceDisconnectedError).

timeout_ms: Aikakatkaisu millisekunteina tai None ilman aikakatkaisua.

exchange_mtu(mtu: int | None = None, timeout_ms: int = 1000) → Awaitable[int]¶

Asynkroninen. Käynnistä ATT MTU -vaihto ja palauta neuvoteltu MTU.

mtu: Valinnainen halutta MTU asetettavaksi taustalla olevaan BLE-rajapintaan ennen vaihtoa.
timeout_ms: Vaihdon aikakatkaisu.

service(uuid: bluetooth.UUID, timeout_ms: int = 2000) → Awaitable[ClientService | None]¶: Asynkroninen. Löydä yksittäinen etäpalvelu, joka täsmää uuid -arvoon, tai None jos ei löydy.

services(uuid: bluetooth.UUID | None = None, timeout_ms: int = 2000) → ClientDiscover¶

Palauta asynkroninen iteraattori etä-ClientService -objekteista. Käytä async for -rakenteen kanssa ja suorita silmukka loppuun.

uuid: Valinnainen UUID-suodatin. None palauttaa jokaisen palvelun.
timeout_ms: Löytökohtainen aikakatkaisu.

pair(bond: bool = True, le_secure: bool = True, mitm: bool = False, io: int = 3, timeout_ms: int = 20000) → Awaitable[None]¶

Asynkroninen. Käynnistä paritus tällä yhteydellä. Päivittää encrypted / authenticated / bonded / key_size -attribuutit valmistuttuaan.

bond: Säilytä paritusavaimet pysyvästi.
le_secure: Käytä LE Secure Connections -menetelmää.
mitm: Vaadi man-in-the-middle-suojaus.
io: IO-kykyvakio (esim. 3 ei syötettä/tulostetta varten).
timeout_ms: Parituksen aikakatkaisu.

l2cap_accept(psm: int, mtu: int, timeout_ms: int | None = None) → Awaitable[L2CAPChannel]¶

Asynkroninen. Kuuntele annettua PSM:ää ja palauta L2CAPChannel kun etäpää avaa sen.

psm: Protocol/Service Multiplexer, jota kuunnellaan.
mtu: Maksimivastaanottokoko tavuina.
timeout_ms: Maksimiaika odottaa, että etäpää yhdistää.

l2cap_connect(psm: int, mtu: int, timeout_ms: int = 1000) → Awaitable[L2CAPChannel]¶

Asynkroninen. Avaa L2CAP-kanava etäpäähän annetulla PSM:llä.

psm: Protocol/Service Multiplexer, johon yhdistetään.
mtu: Maksimivastaanottokoko tavuina.
timeout_ms: Yhteyden aikakatkaisu.

class aioble.ScanResult¶

Yksittäinen scan -toiminnon aikana löydetty laite. Sama ilmentymä tuotetaan uudelleen, kun uutta mainosdataa saapuu.

Älä muodosta suoraan.

device¶: Taustalla oleva Device.

rssi¶: Viimeksi raportoitu RSSI dBm-yksikössä.

adv_data¶: Raaka mainospayload (bytes tai None).

resp_data¶: Raaka skannausvastauspayload (bytes tai None), jos aktiivinen skannaus on käytössä.

connectable¶: True jos viimeisin mainos oli yhdistettävissä.

name() → str | None¶: Pura täydellinen (tai lyhennetty) mainostettu paikallinen nimi payloadista tai None jos sitä ei ole.

services() → Iterator[bluetooth.UUID]¶: Generaattori, joka tuottaa jokaisen bluetooth.UUID -arvon, jota mainostetaan 16/32/128-bittisissä palveluluettelokentissä.

manufacturer(filter: int | None = None) → Iterator[tuple[int, bytes]]¶

Generaattori, joka tuottaa (company_id, data) -monikoita valmistajakohtaisista mainoskentistä.

filter: Jos annettu, tuota vain ne tietueet, joiden company ID täsmää.

class aioble.Service(uuid: bluetooth.UUID)¶

Paikallinen GATT-palvelu. Rakenna palvelu yhdellä tai useammalla Characteristic -ilmentymällä ja välitä se sitten metodille register_services.

uuid: Palvelun UUID.

uuid¶: Palvelun UUID.

characteristics¶: Luettelo tähän palveluun sidotuista Characteristic -objekteista.

class aioble.Characteristic(service: Service, uuid: bluetooth.UUID, read: bool = False, write: bool = False, write_no_response: bool = False, notify: bool = False, indicate: bool = False, initial: bytes | None = None, capture: bool = False)¶

Paikallinen GATT-ominaisuus. Sellaisen muodostaminen liittää sen automaattisesti service -palveluun.

service: Omistava Service.
uuid: Ominaisuuden UUID.
read, write, write_no_response, notify, indicate: Totuusarvot, jotka valitsevat tuetut GATT-operaatiot.
initial: Valinnainen alkuarvo (bytes).
capture: Jos True, kirjoitetut arvot jonotetaan (enintään 10 syvyyteen), jotta nopeita peräkkäisiä kirjoituksia ei menetetä. Kukin written -kutsu palauttaa tällöin (connection, data) -monikon.

uuid¶: Ominaisuuden UUID.

flags¶: Bittimaski GATT-ominaisuuslipuista, jotka rakennetaan konstruktorista.

descriptors¶: Luettelo tähän ominaisuuteen sidotuista Descriptor -objekteista.

read() → bytes¶: Lue nykyinen arvo paikallisesta GATT-tietokannasta.

write(data: bytes, send_update: bool = False) → None¶

Päivitä arvo paikallisessa GATT-tietokannassa.

data: Uudet arvotavut.
send_update: Jos True, ilmoita/osoita myös jokaiselle tilanneelle yhteydelle.

notify(connection: DeviceConnection, data: bytes | None = None) → None¶

Lähetä GATT Notify osoitteeseen connection.

connection: Kohdeasiakasyhteys.
data: Lähetettävä payload. Jos None, lähetetään nykyinen paikallinen arvo.

indicate(connection: DeviceConnection, data: bytes | None = None, timeout_ms: int = 1000) → Awaitable[None]¶

Asynkroninen. Lähetä GATT Indicate osoitteeseen connection ja odota asiakkaan vahvistusta. Nostaa GattError -poikkeuksen nollasta poikkeavalla tilalla.

connection: Kohdeasiakasyhteys.
data: Osoitettava payload tai None paikallisen arvon lähettämiseksi.
timeout_ms: Maksimiaika vahvistuksen odottamiseen.

written(timeout_ms: int | None = None) → Awaitable[DeviceConnection | tuple[DeviceConnection, bytes]]¶

Asynkroninen. Odota etäkirjoitusta. Palauttaa kirjoittavan DeviceConnection -yhteyden tai (connection, data) jos ominaisuus luotiin asetuksella capture=True.

timeout_ms: Maksimiaika odottamiseen. None odottaa ikuisesti.

on_read(connection: DeviceConnection) → int¶: Ohitettava hook, joka suoritetaan synkronisesti, kun etäluku vastaanotetaan. Palauta 0 salliaksesi luvun tai nollasta poikkeava ATT-virhekoodi hylätäksesi sen. Oletustoteutus palauttaa 0.

class aioble.BufferedCharacteristic(service: Service, uuid: bluetooth.UUID, max_len: int = 20, append: bool = False, **kwargs)¶

Characteristic, jonka taustalla oleva GATT-puskuri on määritettävissä. Hyödyllinen oletusattribuuttikokoa suurempien arvojen vastaanottamiseen tai peräkkäisten kirjoitusten jonottamiseen.

max_len: Puskurin koko tavuina.
append: Jos True, peräkkäiset kirjoitukset liitetään puskuriin ylikirjoittamisen sijaan.

Muut argumentit välitetään edelleen Characteristic -luokalle.

class aioble.Descriptor(characteristic: Characteristic, uuid: bluetooth.UUID, read: bool = False, write: bool = False, initial: bytes | None = None)¶

Paikallinen GATT-kuvaaja. Sellaisen muodostaminen liittää sen automaattisesti characteristic -ominaisuuteen. Perii metodit read, write ja written luokalta Characteristic.

characteristic: Omistava Characteristic.
uuid: Kuvaajan UUID.
read, write: Totuusarvot, jotka valitsevat tuetut GATT-operaatiot.
initial: Valinnainen alkuarvo (bytes).

class aioble.ClientService¶

Vertaiselta löydetty etä-GATT-palvelu. Palauttaa DeviceConnection.service() tai iteroidaan metodista DeviceConnection.services().

Älä muodosta suoraan.

connection¶: Omistava DeviceConnection.

uuid¶: Etäpalvelun UUID.

characteristic(uuid: bluetooth.UUID, timeout_ms: int = 2000) → Awaitable[ClientCharacteristic | None]¶: Asynkroninen. Löydä yksittäinen ominaisuus UUID:n perusteella tai None jos ei löydy.

characteristics(uuid: bluetooth.UUID | None = None, timeout_ms: int = 2000) → ClientDiscover¶

Palauta asynkroninen iteraattori ClientCharacteristic -objekteista. Käytä async for -rakenteen kanssa ja suorita silmukka loppuun.

uuid: Valinnainen UUID-suodatin.
timeout_ms: Löytökohtainen aikakatkaisu.

class aioble.ClientCharacteristic¶

Vertaiselta löydetty etä-GATT-ominaisuus. Palauttaa ClientService.characteristic() tai iteroidaan metodista ClientService.characteristics().

Älä muodosta suoraan.

service¶: Omistava ClientService.

uuid¶: Ominaisuuden UUID.

properties¶: Bittimaski tuetuista GATT-operaatioista vertaisen raportoimana.

read(timeout_ms: int = 1000) → Awaitable[bytes]¶

Asynkroninen. Suorita GATT Read ja palauta arvo. Nostaa GattError -poikkeuksen nollasta poikkeavalla tilalla.

timeout_ms: Luvun aikakatkaisu.

write(data: bytes, response: bool | None = None, timeout_ms: int = 1000) → Awaitable[None]¶

Asynkroninen. Suorita GATT Write.

data: Kirjoitettava arvo.
response: True vaatii kirjoitusvastauksen (ja nostaa GattError -poikkeuksen epäonnistuessa). False write-without-response-toimintoa varten. None (oletus) valitsee automaattisesti sen perusteella, mitä vertainen mainostaa.
timeout_ms: Kirjoituksen aikakatkaisu (merkityksellinen vain jos response on True).

notified(timeout_ms: int | None = None) → Awaitable[bytes]¶

Asynkroninen. Odota seuraavaa ilmoitusta tästä ominaisuudesta ja palauta sen payload. Palaa välittömästi, jos ilmoitus on jo jonossa.

timeout_ms: Maksimiaika odottamiseen. None odottaa ikuisesti.

indicated(timeout_ms: int | None = None) → Awaitable[bytes]¶

Asynkroninen. Odota seuraavaa osoitusta tästä ominaisuudesta ja palauta sen payload.

timeout_ms: Maksimiaika odottamiseen.

subscribe(notify: bool = True, indicate: bool = False) → Awaitable[None]¶

Asynkroninen. Kirjoita Client Characteristic Configuration Descriptor (CCCD) tilataksesi (tai peruuttaaksesi tilauksen) ilmoituksille ja/tai osoituksille.

notify: Ota ilmoitukset käyttöön.
indicate: Ota osoitukset käyttöön.

descriptor(uuid: bluetooth.UUID, timeout_ms: int = 2000) → Awaitable[ClientDescriptor | None]¶: Asynkroninen. Löydä yksittäinen kuvaaja UUID:n perusteella tai None jos ei löydy.

descriptors(timeout_ms: int = 2000) → ClientDiscover¶: Palauta asynkroninen iteraattori ClientDescriptor -objekteista. Käytä async for -rakenteen kanssa ja suorita silmukka loppuun.

class aioble.ClientDescriptor¶

Vertaiselta löydetty etä-GATT-kuvaaja. Perii metodit read ja write luokalta ClientCharacteristic.

Älä muodosta suoraan.

characteristic¶: Omistava ClientCharacteristic.

uuid¶: Kuvaajan UUID.

class aioble.L2CAPChannel¶

Aktiivinen L2CAP-yhteyssuuntautunut kanava. Palauttaa DeviceConnection.l2cap_accept() tai DeviceConnection.l2cap_connect(). Tukee käyttöä async with -kontekstinhallitsijana, joka katkaisee yhteyden automaattisesti poistuttaessa.

Älä muodosta suoraan.

our_mtu¶: Maksimikoko tavuina, jonka vertainen voi lähettää meille yhdessä SDU:ssa.

peer_mtu¶: Maksimikoko tavuina, jonka me voimme lähettää vertaiselle yhdessä SDU:ssa.

available() → bool¶: Palauttaa synkronisesti True jos puskuroitua vastaanottodataa on valmiina (eli recvinto ei estä).

recvinto(buf: bytearray, timeout_ms: int | None = None) → Awaitable[int]¶

Asynkroninen. Vastaanota puskuriin buf ja palauta luettujen tavujen määrä. Odottaa uutta dataa, jos kanava on tyhjä.

buf: Esivarattu puskuri täytettäväksi.
timeout_ms: Maksimiaika odottamiseen. None odottaa ikuisesti.

send(buf: bytes, timeout_ms: int | None = None, chunk_size: int | None = None) → Awaitable[None]¶

Asynkroninen. Lähetä buf kanavalle pilkkoen suuremmat payloadit MTU-kokoisiin paloihin. Odottaa vuonohjauskrediittejä tarpeen mukaan.

buf: Tavutyyppinen objekti lähetettäväksi.
timeout_ms: Maksimiaika odottamiseen palaa kohden.
chunk_size: Valinnainen ohitus kutsukohtaiselle palan koolle. Rajattu arvoon min(our_mtu * 2, peer_mtu).

flush(timeout_ms: int | None = None) → Awaitable[None]¶

Asynkroninen. Odota, kunnes ohjain on tyhjentänyt mahdollisen pysähtyneen send -lähetyksen.

timeout_ms: Maksimiaika odottamiseen.

disconnect(timeout_ms: int = 1000) → Awaitable[None]¶

Asynkroninen. Katkaise kanava ja odota katkaisun IRQ:ta.

timeout_ms: Maksimiaika odottamiseen.

disconnected(timeout_ms: int = 1000) → Awaitable[None]¶

Asynkroninen. Odota, kunnes jompikumpi osapuoli katkaisee kanavan.

timeout_ms: Maksimiaika odottamiseen.

aioble — Asynkroninen BLE¶

Esimerkit¶

Moduulitason funktiot¶

Moduulitason vakiot¶

Poikkeukset¶

Luokat¶

`aioble` — Asynkroninen BLE¶