`aioble` — Aszinkron BLE¶

Az aioble egy magas szintű, asyncio-barát csomagolóréteg a bluetooth modul köré. Tiszta korutinokat biztosít a kereséshez, kapcsolódáshoz, hirdetéshez, GATT-szolgáltatásokhoz és L2CAP-csatornákhoz.

Minden távoli művelet (connect, disconnect, kliensoldali olvasás/írás, szerveroldali indicate, l2cap recv/send, párosítás) várakoztatható (awaitable) és támogatja az időtúllépéseket.

Támogatott szerepkörök:

Broadcaster (hirdető) — hirdetési és válasz-keresési (scan-response) hasznos adatok előállítása gyakori mezőkhöz, a hasznos adat automatikus szétosztása a hirdetés és a válasz-keresés között, hirdetés korlátlan ideig vagy rögzített időtartamra.
Peripheral (periféria) — várakozás egy central csatlakozására, várakozás az MTU-cserére.
Observer (kereső) — passzív és aktív keresés, ugyanazon eszköz hirdetési és válasz-keresési hasznos adatainak egyesítése, gyakori mezők kinyerése a hirdetési hasznos adatokból.
Central — kapcsolódás egy perifériához, MTU-csere kezdeményezése.
GATT-kliens — szolgáltatások / jellemzők / leírók felderítése (opcionálisan UUID szerint); olvasás / írás / válaszos írás jellemzőkön és leírókon; feliratkozás értesítésekre (notification) és jelzésekre (indication) (a CCCD-n keresztül); várakozás értesítésekre és jelzésekre.
GATT-szerver — szolgáltatások / jellemzők / leírók regisztrálása; várakozás jellemzőkre és leírókra történő írásokra; olvasási kérések elfogása; értesítések és jelzések küldése (és válaszra várakozás).
L2CAP — L2CAP kapcsolatorientált csatornák fogadása és kapcsolódása, csatorna folyamszabályozásának kezelése.
Biztonság — JSON-alapú kulcs-/titokkezelés, párosítás kezdeményezése, titkosítási / hitelesítési állapot lekérdezése.

Példák¶

Közeli BLE-eszközök keresése, és mindegyik kiírása, ahogy észlelhetővé válik:

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

Kapcsolódás central szerepkörben egy a Heart Rate szolgáltatást hirdető perifériához, és feliratkozás a mérési értesítéseire:

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

Viselkedés peripheral szerepkörben: GATT-szolgáltatás regisztrálása, annak hirdetése, és értesítések küldése bárkinek, aki csatlakozik:

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

Modulszintű függvények¶

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

Továbbít a bluetooth.BLE.config() felé, először biztosítva, hogy a BLE-rádió aktív legyen.

args: Egyetlen opcionális paraméternév, amelyet le kell kérdezni.
kwargs: Kulcsszavas argumentumok konfigurációs értékek beállításához.

aioble.stop() → None¶: Deaktiválja a mögöttes BLE-rádiót, és lefuttatja az összes regisztrált almodul-leállítókezelőt. Ennek meghívása után a keresők, hirdetők, kapcsolatok és L2CAP-csatornák mind lebontásra kerülnek.

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

Egy scan aszinkron kontextuskezelőt / aszinkron iterátort ad vissza, amely ScanResult példányokat szolgáltat minden felfedezett egyedi eszközhöz (vagy egy ismert eszköz minden új hirdetési adatdarabjához).

duration_ms: Mennyi ideig keressen, ezredmásodpercben. Adj át 0 értéket a korlátlan kereséshez, amíg a kontextuskezelő ki nem lép.
interval_us: Keresési intervallum mikroszekundumban. Alapértelmezetten 1 280 000.
window_us: Keresési ablak mikroszekundumban (kisebbnek vagy egyenlőnek kell lennie, mint interval_us). Alapértelmezetten 11 250.
active: Ha True, aktív keresést végez (válasz-keresési adatokat kér). Alapértelmezetten 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¶

Aszinkron korutin, amely elkezdi a hirdetést, és bejövő central kapcsolatra vár. Egy DeviceConnection objektumot ad vissza, amely a csatlakozott central eszközt képviseli, vagy asyncio.TimeoutError kivételt vált ki időtúllépéskor.

interval_us: Hirdetési intervallum mikroszekundumban.
adv_data: Nyers hirdetési hasznos adat. Ha nincs beállítva, az adv_data a fennmaradó kulcsszavas argumentumokból épül fel.
resp_data: Nyers válasz-keresési hasznos adat. Automatikusan feltöltődik az adv_data túlcsordulásából, ha szükséges.
connectable: Ha True, ez egy csatlakoztatható hirdetés.
limited_disc: A korlátozottan felfedezhető (limited-discoverable) jelzőt használja az általános helyett.
br_edr: Beállítja a BR/EDR-támogatott jelzőt.
name: Opcionális teljes helyi név beágyazáshoz.
services: bluetooth.UUID objektumok iterálható gyűjteménye a hirdetéshez.
appearance: 16 bites megjelenés (appearance) érték (lásd a Bluetooth hozzárendelt számokat).
manufacturer: Egy (company_id, data_bytes) rendezett pár, amelyet gyártóspecifikus adatként kell hirdetni.
timeout_ms: Leállítja a hirdetést ennyi ezredmásodperc után, ha nincs kapcsolat. A None azt jelenti, hogy a hirdetés a kapcsolódásig tart.

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

Regisztrál egy vagy több Service objektumot (és azok jellemzőit és leíróit) a GATT-szervernél. Egyszer meg kell hívni a advertise indítása előtt. A további hívások felülírják a korábbi regisztrációt.

services: Egy vagy több Service példány.

Modulszintű konstansok¶

aioble.ADDR_PUBLIC¶: Nyilvános BLE-eszközcím típusa (0).

aioble.ADDR_RANDOM¶: Véletlenszerű BLE-eszközcím típusa (1).

Kivételek¶

exception aioble.GattError¶: Akkor váltódik ki, amikor egy távoli GATT-művelet (olvasás / írás / indicate) nem nulla állapottal fejeződik be. Az állapotkód a _status attribútumon érhető el.

exception aioble.DeviceDisconnectedError¶: Akkor váltódik ki egy aszinkron művelet (pl. read, write, notified) belsejében, amikor a mögöttes kapcsolat megszakad várakozás közben.

exception aioble.L2CAPDisconnectedError¶: Akkor váltódik ki, amikor egy L2CAP-csatorna küldési/fogadási/ürítési műveletét lecsatlakoztatott csatornán kísérlik meg (vagy az ilyen csatorna szakítja meg).

exception aioble.L2CAPConnectionError¶: A DeviceConnection.l2cap_connect váltja ki, amikor a csatorna létrehozása sikertelen. A Bluetooth-állapotkód az első argumentum.

Osztályok¶

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

Egy távoli BLE-eszközt képvisel cím alapján. Két Device példány akkor egyenlő, ha mind az addr_type, mind az addr egyezik. A kapcsolatok kezdeményezésének fogantyújaként (handle) használatos.

addr_type: Vagy ADDR_PUBLIC, vagy ADDR_RANDOM.
addr: Hatbájtos cím bytes formában, vagy kettősponttal elválasztott hexadecimális karakterlánc (pl. "aa:bb:cc:dd:ee:ff").

addr_type¶: A címtípus, amellyel az eszköz létre lett hozva.

addr¶: A nyers hatbájtos eszközcím.

addr_hex() → str¶: Visszaadja a címet kettősponttal elválasztott hexadecimális karakterláncként.

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]¶

Aszinkron. GAP-kapcsolatot kezdeményez ehhez az eszközhöz, és visszaadja a létrejövő DeviceConnection objektumot. Megszakít minden folyamatban lévő keresést.

timeout_ms: Mennyi ideig várjon a kapcsolat befejezésére.
scan_duration_ms: Kezdeti keresési időtartam a kapcsolódás előtt (vezérlőspecifikus).
min_conn_interval_us / max_conn_interval_us: Opcionális kapcsolati intervallum korlátok mikroszekundumban.

class aioble.DeviceConnection¶

Egy aktív GAP-kapcsolat egy Device eszközhöz. A Device.connect() vagy a advertise adja vissza. Támogatja az async with kontextuskezelőként való használatot, amely kilépéskor automatikusan lecsatlakozik.

Ne hozd létre közvetlenül.

device¶: A mögöttes Device.

encrypted¶: True, amint a kapcsolat titkosítva van (pl. párosítás után).

authenticated¶: True, ha a kapcsolat hitelesítve volt (MITM-védett párosítás).

bonded¶: True, ha a párosítás kötési (bonding) kulcsokat hozott létre.

key_size¶: Az egyeztetett titkosítási kulcsméret bájtban, vagy False, ha nincs titkosítva.

mtu¶: Az egyeztetett ATT MTU az exchange_mtu után, vagy None, amíg be nincs állítva.

is_connected() → bool¶: Visszaadja, hogy a kapcsolat még aktív-e.

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

Aszinkron. Lecsatlakozik, és megvárja a lecsatlakozási IRQ-t.

timeout_ms: Maximális várakozási idő a lecsatlakozásra.

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

Aszinkron. Megvárja, amíg a kapcsolatot bármelyik oldal megszünteti. Ha a disconnect True, először aktívan lecsatlakozik.

timeout_ms: Maximális várakozási idő. A None azt jelenti, hogy végtelen ideig vár.
disconnect: Ha True, kezdeményezi a lecsatlakozást.

timeout(timeout_ms: int | None) → DeviceTimeout¶

Visszaad egy kontextuskezelőt, amely megszakítja a törzsét, ha vagy letelik az időtúllépés (asyncio.TimeoutError kivételt váltva ki), vagy az eszköz lecsatlakozik (DeviceDisconnectedError kivételt váltva ki).

timeout_ms: Időtúllépés ezredmásodpercben, vagy None, ha nincs időtúllépés.

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

Aszinkron. Kezdeményez egy ATT MTU-cserét, és visszaadja az egyeztetett MTU-t.

mtu: Opcionális preferált MTU, amelyet a csere előtt be kell állítani a mögöttes BLE-interfészen.
timeout_ms: A csere időtúllépése.

service(uuid: bluetooth.UUID, timeout_ms: int = 2000) → Awaitable[ClientService | None]¶: Aszinkron. Felderít egyetlen, az uuid értékkel egyező távoli szolgáltatást, vagy None értéket, ha nem található.

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

Visszaad egy aszinkron iterátort távoli ClientService objektumokról. Használd async for ciklussal, és futtasd a ciklust a végéig.

uuid: Opcionális UUID-szűrő. A None minden szolgáltatást visszaad.
timeout_ms: Felderítésenkénti időtúllépés.

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

Aszinkron. Párosítást kezdeményez ezen a kapcsolaton. A befejezéskor frissíti az encrypted / authenticated / bonded / key_size attribútumokat.

bond: Tartósan megőrzi a párosítási kulcsokat.
le_secure: LE Secure Connections használata.
mitm: Man-in-the-middle védelmet követel meg.
io: IO-képesség konstans (pl. 3 a be-/kimenet nélküli esethez).
timeout_ms: Párosítási időtúllépés.

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

Aszinkron. A megadott PSM-en figyel, és visszaad egy L2CAPChannel objektumot, amint a távoli fél megnyitja azt.

psm: A Protocol/Service Multiplexer, amelyen figyelni kell.
mtu: Maximális fogadási méret bájtban.
timeout_ms: Maximális várakozási idő a távoli fél kapcsolódására.

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

Aszinkron. L2CAP-csatornát nyit a távoli félhez a megadott PSM-en.

psm: A Protocol/Service Multiplexer, amelyhez kapcsolódni kell.
mtu: Maximális fogadási méret bájtban.
timeout_ms: Kapcsolódási időtúllépés.

class aioble.ScanResult¶

Egyetlen eszköz, amelyet a scan során fedeztek fel. Ugyanaz a példány kerül újra visszaadásra, ahogy új hirdetési adatok érkeznek.

Ne hozd létre közvetlenül.

device¶: A mögöttes Device.

rssi¶: Az utoljára jelentett RSSI dBm-ben.

adv_data¶: Nyers hirdetési hasznos adat (bytes vagy None).

resp_data¶: Nyers válasz-keresési hasznos adat (bytes vagy None), ha az aktív keresés engedélyezve van.

connectable¶: True, ha a legutóbbi hirdetés csatlakoztatható volt.

name() → str | None¶: Dekódolja a teljes (vagy rövidített) hirdetett helyi nevet a hasznos adatból, vagy None értéket, ha nincs jelen.

services() → Iterator[bluetooth.UUID]¶: Generátor, amely minden, a 16/32/128 bites szolgáltatáslista-mezőkben hirdetett bluetooth.UUID objektumot szolgáltat.

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

Generátor, amely (company_id, data) rendezett párokat szolgáltat a gyártóspecifikus hirdetési mezőkből.

filter: Ha meg van adva, csak azokat a bejegyzéseket szolgáltatja, amelyek vállalatazonosítója egyezik.

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

Egy helyi GATT-szolgáltatás. Építsd fel a szolgáltatást egy vagy több Characteristic példánnyal, majd add át a register_services függvénynek.

uuid: A szolgáltatás UUID-je.

uuid¶: A szolgáltatás UUID-je.

characteristics¶: A szolgáltatáshoz kötött Characteristic objektumok listája.

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

Egy helyi GATT-jellemző. Egy ilyen létrehozása automatikusan hozzáfűzi azt a service objektumhoz.

service: A tulajdonos Service.
uuid: A jellemző UUID-je.
read, write, write_no_response, notify, indicate: Logikai értékek, amelyek kiválasztják a támogatott GATT-műveleteket.
initial: Opcionális kezdeti érték (bytes).
capture: Ha True, az írt értékek sorba kerülnek (legfeljebb 10 mélységig), így a gyors, egymást követő írások nem vesznek el. Ekkor minden written hívás egy (connection, data) rendezett párt ad vissza.

uuid¶: A jellemző UUID-je.

flags¶: A konstruktorból felépített GATT-tulajdonságjelzők bitmaszkja.

descriptors¶: A jellemzőhöz kötött Descriptor objektumok listája.

read() → bytes¶: Beolvassa az aktuális értéket a helyi GATT-adatbázisból.

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

Frissíti az értéket a helyi GATT-adatbázisban.

data: Az új érték bájtjai.
send_update: Ha True, minden feliratkozott kapcsolatot is értesít/jelez (notify/indicate).

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

GATT Notify küldése a connection félnek.

connection: A cél klienskapcsolat.
data: A küldendő hasznos adat. Ha None, az aktuális helyi érték kerül elküldésre.

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

Aszinkron. GATT Indicate küldése a connection félnek, és várakozás a kliens megerősítésére. GattError kivételt vált ki nem nulla állapot esetén.

connection: A cél klienskapcsolat.
data: A jelzendő hasznos adat, vagy None a helyi érték elküldéséhez.
timeout_ms: Maximális várakozási idő a megerősítésre.

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

Aszinkron. Várakozás egy távoli írásra. Visszaadja az író DeviceConnection objektumot, vagy egy (connection, data) párt, ha a jellemző capture=True beállítással lett létrehozva.

timeout_ms: Maximális várakozási idő. A None végtelen ideig vár.

on_read(connection: DeviceConnection) → int¶: Felülírható hook, amely szinkron módon hívódik meg, amikor egy távoli olvasás érkezik. Adj vissza 0 értéket az olvasás engedélyezéséhez, vagy egy nem nulla ATT-hibakódot az elutasításához. Az alapértelmezett megvalósítás 0 értéket ad vissza.

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

Egy Characteristic, amelynek mögöttes GATT-puffere konfigurálható. Hasznos az alapértelmezett attribútumméretnél nagyobb értékek fogadásához, vagy az egymást követő írások sorba állításához.

max_len: Pufferméret bájtban.
append: Ha True, az egymást követő írások a pufferbe fűződnek hozzá felülírás helyett.

A többi argumentum a Characteristic felé továbbítódik.

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

Egy helyi GATT-leíró. Egy ilyen létrehozása automatikusan hozzáfűzi azt a characteristic objektumhoz. Örökli a read, write és written metódusokat a Characteristic osztálytól.

characteristic: A tulajdonos Characteristic.
uuid: A leíró UUID-je.
read, write: Logikai értékek, amelyek kiválasztják a támogatott GATT-műveleteket.
initial: Opcionális kezdeti érték (bytes).

class aioble.ClientService¶

Egy távoli GATT-szolgáltatás, amelyet egy partnereszközön fedeztek fel. A DeviceConnection.service() adja vissza, vagy a DeviceConnection.services() iterálásából származik.

Ne hozd létre közvetlenül.

connection¶: A tulajdonos DeviceConnection.

uuid¶: A távoli szolgáltatás UUID-je.

characteristic(uuid: bluetooth.UUID, timeout_ms: int = 2000) → Awaitable[ClientCharacteristic | None]¶: Aszinkron. Felderít egyetlen jellemzőt UUID alapján, vagy None értéket, ha nem található.

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

Visszaad egy aszinkron iterátort ClientCharacteristic objektumokról. Használd async for ciklussal, és futtasd a ciklust a végéig.

uuid: Opcionális UUID-szűrő.
timeout_ms: Felderítésenkénti időtúllépés.

class aioble.ClientCharacteristic¶

Egy távoli GATT-jellemző, amelyet egy partnereszközön fedeztek fel. A ClientService.characteristic() adja vissza, vagy a ClientService.characteristics() iterálásából származik.

Ne hozd létre közvetlenül.

service¶: A tulajdonos ClientService.

uuid¶: A jellemző UUID-je.

properties¶: A támogatott GATT-műveletek bitmaszkja a partner által jelentett módon.

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

Aszinkron. GATT Read kiadása, és az érték visszaadása. GattError kivételt vált ki nem nulla állapot esetén.

timeout_ms: Olvasási időtúllépés.

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

Aszinkron. GATT Write kiadása.

data: Az írandó érték.
response: True a válaszos írás megköveteléséhez (és GattError kivétel kiváltásához hiba esetén). False a válasz nélküli íráshoz. A None (alapértelmezett) automatikusan választ a partner által hirdetettek alapján.
timeout_ms: Írási időtúllépés (csak akkor releváns, ha a response értéke True).

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

Aszinkron. Várakozás a következő értesítésre ezen a jellemzőn, és annak hasznos adatának visszaadása. Azonnal visszatér, ha már sorban áll egy értesítés.

timeout_ms: Maximális várakozási idő. A None végtelen ideig vár.

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

Aszinkron. Várakozás a következő jelzésre ezen a jellemzőn, és annak hasznos adatának visszaadása.

timeout_ms: Maximális várakozási idő.

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

Aszinkron. A Client Characteristic Configuration Descriptor (CCCD) megírása az értesítésekre és/vagy jelzésekre való feliratkozáshoz (vagy leiratkozáshoz).

notify: Engedélyezi az értesítéseket.
indicate: Engedélyezi a jelzéseket.

descriptor(uuid: bluetooth.UUID, timeout_ms: int = 2000) → Awaitable[ClientDescriptor | None]¶: Aszinkron. Felderít egyetlen leírót UUID alapján, vagy None értéket, ha nem található.

descriptors(timeout_ms: int = 2000) → ClientDiscover¶: Visszaad egy aszinkron iterátort ClientDescriptor objektumokról. Használd async for ciklussal, és futtasd a ciklust a végéig.

class aioble.ClientDescriptor¶

Egy távoli GATT-leíró, amelyet egy partnereszközön fedeztek fel. Örökli a read és write metódusokat a ClientCharacteristic osztálytól.

Ne hozd létre közvetlenül.

characteristic¶: A tulajdonos ClientCharacteristic.

uuid¶: A leíró UUID-je.

class aioble.L2CAPChannel¶

Egy aktív L2CAP kapcsolatorientált csatorna. A DeviceConnection.l2cap_accept() vagy a DeviceConnection.l2cap_connect() adja vissza. Támogatja az async with kontextuskezelőként való használatot, amely kilépéskor automatikusan lecsatlakozik.

Ne hozd létre közvetlenül.

our_mtu¶: Maximális méret bájtban, amelyet a partner egyetlen SDU-ban küldhet nekünk.

peer_mtu¶: Maximális méret bájtban, amelyet egyetlen SDU-ban küldhetünk a partnernek.

available() → bool¶: Szinkron módon True értéket ad vissza, ha pufferelt fogadási adat áll készen (azaz a recvinto nem fog blokkolni).

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

Aszinkron. Fogadás a buf pufferbe, visszaadva a beolvasott bájtok számát. Új adatra vár, ha a csatorna üres.

buf: Előre lefoglalt puffer, amelyet fel kell tölteni.
timeout_ms: Maximális várakozási idő. A None végtelen ideig vár.

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

Aszinkron. A buf elküldése a csatornán, a nagyobb hasznos adatokat MTU-méretű darabokra tördelve. Szükség szerint folyamszabályozási kreditekre vár.

buf: Bájtszerű (bytes-like) objektum a küldéshez.
timeout_ms: Maximális várakozási idő darabonként.
chunk_size: Opcionális felülírás a hívásonkénti darabmérethez. A min(our_mtu * 2, peer_mtu) értékre korlátozva.

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

Aszinkron. Várakozás, amíg minden megakadt send műveletet a vezérlő ki nem ürített.

timeout_ms: Maximális várakozási idő.

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

Aszinkron. Lecsatlakoztatja a csatornát, és megvárja a lecsatlakozási IRQ-t.

timeout_ms: Maximális várakozási idő.

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

Aszinkron. Várakozás, amíg a csatornát bármelyik oldal le nem csatlakoztatja.

timeout_ms: Maximális várakozási idő.

aioble — Aszinkron BLE¶

Példák¶

Modulszintű függvények¶

Modulszintű konstansok¶

Kivételek¶

Osztályok¶

`aioble` — Aszinkron BLE¶