`aioble` — Asynchroniczne BLE#

aioble to wysokopoziomowa, przyjazna dla asyncio nakładka na moduł bluetooth. Udostępnia czyste korutyny do skanowania, łączenia, rozgłaszania, usług GATT oraz kanałów L2CAP.

Wszystkie operacje zdalne (połączenie, rozłączenie, odczyt/zapis klienta, indykacja serwera, odbiór/wysyłka l2cap, parowanie) są oczekiwalne (awaitable) i obsługują limity czasu.

Obsługiwane role:

Broadcaster (rozgłaszający) — generuje ładunki rozgłaszania i odpowiedzi na skanowanie dla typowych pól, automatycznie dzieli ładunek pomiędzy rozgłaszanie a odpowiedź na skanowanie, rozgłasza bez ograniczeń lub przez określony czas.
Peripheral (urządzenie peryferyjne) — oczekuje na połączenie od urządzenia centralnego, oczekuje na wymianę MTU.
Observer (skaner) — skanowanie pasywne i aktywne, łączenie ładunków rozgłaszania i odpowiedzi na skanowanie dla tego samego urządzenia, parsowanie typowych pól z ładunków rozgłaszania.
Central (urządzenie centralne) — łączy się z urządzeniem peryferyjnym, inicjuje wymianę MTU.
Klient GATT — wykrywa usługi / charakterystyki / deskryptory (opcjonalnie po UUID); odczytuje / zapisuje / zapisuje-z-odpowiedzią charakterystyki i deskryptory; subskrybuje powiadomienia i indykacje (poprzez CCCD); oczekuje na powiadomienia i indykacje.
Serwer GATT — rejestruje usługi / charakterystyki / deskryptory; oczekuje na zapisy w charakterystykach i deskryptorach; przechwytuje żądania odczytu; wysyła powiadomienia i indykacje (oraz oczekuje na odpowiedź).
L2CAP — akceptuje i nawiązuje połączeniowe kanały L2CAP, zarządza kontrolą przepływu kanału.
Bezpieczeństwo — zarządzanie kluczami/sekretami w oparciu o JSON, inicjowanie parowania, odpytywanie o stan szyfrowania / uwierzytelnienia.

Przykłady#

Skanuje pobliskie urządzenia BLE i wypisuje każde z nich w miarę ich wykrywania:

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

Łączy się z urządzeniem peryferyjnym rozgłaszającym usługę Heart Rate jako central i subskrybuje jego powiadomienia o pomiarach:

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

Działa jako peripheral: rejestruje usługę GATT, rozgłasza ją i przesyła powiadomienia do każdego, kto się połączy:

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

Funkcje na poziomie modułu#

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

Przekazuje do bluetooth.BLE.config(), upewniając się najpierw, że radio BLE jest aktywne.

args: Opcjonalna pojedyncza nazwa parametru do odpytania.
kwargs: Argumenty nazwane służące do ustawiania wartości konfiguracyjnych.

aioble.stop() → None#: Dezaktywuje radio BLE leżące u podstaw modułu i uruchamia wszelkie zarejestrowane procedury zamykania podmodułów. Po wywołaniu tej funkcji wszystkie skanery, rozgłaszania, połączenia i kanały L2CAP zostają zlikwidowane.

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

Zwraca asynchroniczny menedżer kontekstu / asynchroniczny iterator scan, który dla każdego unikalnego wykrytego urządzenia (lub dla każdej nowej porcji danych rozgłaszania ze znanego urządzenia) udostępnia instancje ScanResult.

duration_ms: Jak długo skanować, w milisekundach. Przekaż 0, aby skanować bez ograniczeń, aż menedżer kontekstu zostanie zakończony.
interval_us: Interwał skanowania w mikrosekundach. Domyślnie 1 280 000.
window_us: Okno skanowania w mikrosekundach (musi być mniejsze lub równe interval_us). Domyślnie 11 250.
active: Jeśli True, wykonuje skanowanie aktywne (żąda danych odpowiedzi na skanowanie). Domyślnie 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#

Korutyna asynchroniczna, która rozpoczyna rozgłaszanie i oczekuje na przychodzące połączenie od urządzenia centralnego. Zwraca DeviceConnection reprezentujące połączone urządzenie centralne lub zgłasza asyncio.TimeoutError po upływie limitu czasu.

interval_us: Interwał rozgłaszania, w mikrosekundach.
adv_data: Surowy ładunek rozgłaszania. Jeśli nie zostanie ustawiony, adv_data jest budowany z pozostałych argumentów nazwanych.
resp_data: Surowy ładunek odpowiedzi na skanowanie. Automatycznie wypełniany nadmiarem z adv_data, jeśli to konieczne.
connectable: Jeśli True, jest to rozgłaszanie umożliwiające połączenie.
limited_disc: Użyj flagi ograniczonej wykrywalności zamiast ogólnej.
br_edr: Ustaw flagę obsługi BR/EDR.
name: Opcjonalna pełna nazwa lokalna do osadzenia.
services: Obiekt iterowalny zawierający bluetooth.UUID do rozgłaszania.
appearance: 16-bitowa wartość wyglądu (appearance) (zobacz przypisane numery Bluetooth).
manufacturer: Krotka (company_id, data_bytes) do rozgłaszania jako dane specyficzne dla producenta.
timeout_ms: Zatrzymaj rozgłaszanie po upływie tylu milisekund bez połączenia. None oznacza rozgłaszanie aż do nawiązania połączenia.

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

Rejestruje jeden lub więcej obiektów Service (oraz ich charakterystyki i deskryptory) na serwerze GATT. Musi zostać wywołana raz przed uruchomieniem advertise. Kolejne wywołania zastępują poprzednią rejestrację.

services: Jedna lub więcej instancji Service.

Stałe na poziomie modułu#

aioble.ADDR_PUBLIC#: Publiczny typ adresu urządzenia BLE (0).

aioble.ADDR_RANDOM#: Losowy typ adresu urządzenia BLE (1).

Wyjątki#

exception aioble.GattError#: Zgłaszany, gdy zdalna operacja GATT (odczyt / zapis / indykacja) kończy się statusem niezerowym. Kod statusu jest dostępny w atrybucie _status.

exception aioble.DeviceDisconnectedError#: Zgłaszany wewnątrz operacji asynchronicznej (np. odczyt, zapis, powiadomienie), gdy połączenie leżące u jej podstaw zostanie przerwane w trakcie oczekiwania.

exception aioble.L2CAPDisconnectedError#: Zgłaszany, gdy operacja wysyłki/odbioru/opróżnienia kanału L2CAP jest próbowana na rozłączonym kanale (lub zostaje przez niego przerwana).

exception aioble.L2CAPConnectionError#: Zgłaszany przez DeviceConnection.l2cap_connect, gdy nawiązanie kanału się nie powiedzie. Kod statusu Bluetooth jest pierwszym argumentem.

Klasy#

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

Reprezentuje zdalne urządzenie BLE według adresu. Dwie instancje Device są uznawane za równe, jeśli zgadzają się zarówno addr_type, jak i addr. Używane jako uchwyt do inicjowania połączeń.

addr_type: Albo ADDR_PUBLIC, albo ADDR_RANDOM.
addr: Sześciobajtowy adres jako bytes lub ciąg szesnastkowy rozdzielony dwukropkami (np. "aa:bb:cc:dd:ee:ff").

addr_type#: Typ adresu, z którym utworzono urządzenie.

addr#: Surowy sześciobajtowy adres urządzenia.

addr_hex() → str#: Zwraca adres sformatowany jako ciąg szesnastkowy rozdzielony dwukropkami.

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

Asynchroniczna. Inicjuje połączenie GAP z tym urządzeniem i zwraca powstałe DeviceConnection. Anuluje wszelkie trwające skanowanie.

timeout_ms: Jak długo czekać na zakończenie połączenia.
scan_duration_ms: Początkowy czas skanowania przed połączeniem (zależny od kontrolera).
min_conn_interval_us / max_conn_interval_us: Opcjonalne granice interwału połączenia, w mikrosekundach.

class aioble.DeviceConnection#

Aktywne połączenie GAP z urządzeniem Device. Zwracane przez Device.connect() lub advertise. Obsługuje użycie jako menedżer kontekstu async with automatycznie rozłączający się przy wyjściu.

Nie należy tworzyć bezpośrednio.

device#: Leżące u podstaw urządzenie Device.

encrypted#: True, gdy łącze jest zaszyfrowane (np. po sparowaniu).

authenticated#: True, jeśli łącze zostało uwierzytelnione (parowanie zabezpieczone przed atakiem MITM).

bonded#: True, jeśli parowanie wytworzyło klucze powiązania (bonding).

key_size#: Wynegocjowany rozmiar klucza szyfrowania w bajtach lub False, jeśli nie jest zaszyfrowane.

mtu#: Wynegocjowane ATT MTU po exchange_mtu lub None, dopóki nie zostanie ustawione.

is_connected() → bool#: Zwraca informację, czy połączenie jest nadal aktywne.

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

Asynchroniczna. Rozłącza i czeka na przerwanie (IRQ) rozłączenia.

timeout_ms: Maksymalny czas oczekiwania na rozłączenie.

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

Asynchroniczna. Oczekuje na zakończenie połączenia przez którąkolwiek ze stron. Jeśli disconnect ma wartość True, najpierw aktywnie rozłącza.

timeout_ms: Maksymalny czas oczekiwania. None oznacza oczekiwanie w nieskończoność.
disconnect: Jeśli True, inicjuje rozłączenie.

timeout(timeout_ms: int | None) → DeviceTimeout#

Zwraca menedżer kontekstu, który anuluje swoje ciało, jeśli upłynie limit czasu (zgłaszając asyncio.TimeoutError) lub urządzenie się rozłączy (zgłaszając DeviceDisconnectedError).

timeout_ms: Limit czasu w milisekundach lub None dla braku limitu czasu.

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

Asynchroniczna. Inicjuje wymianę ATT MTU i zwraca wynegocjowane MTU.

mtu: Opcjonalne preferowane MTU do ustawienia na leżącym u podstaw interfejsie BLE przed wymianą.
timeout_ms: Limit czasu dla wymiany.

service(uuid: bluetooth.UUID, timeout_ms: int = 2000) → Awaitable[ClientService | None]#: Asynchroniczna. Wykrywa pojedynczą zdalną usługę pasującą do uuid lub None, jeśli nie zostanie znaleziona.

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

Zwraca asynchroniczny iterator zdalnych obiektów ClientService. Używaj z async for i wykonaj pętlę do końca.

uuid: Opcjonalny filtr UUID. None zwraca każdą usługę.
timeout_ms: Limit czasu na wykrycie.

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

Asynchroniczna. Inicjuje parowanie na tym połączeniu. Po zakończeniu aktualizuje atrybuty encrypted / authenticated / bonded / key_size.

bond: Utrwala klucze parowania.
le_secure: Użyj LE Secure Connections.
mitm: Wymagaj ochrony przed atakiem typu man-in-the-middle.
io: Stała zdolności IO (np. 3 dla braku wejścia/wyjścia).
timeout_ms: Limit czasu parowania.

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

Asynchroniczna. Nasłuchuje na podanym PSM i zwraca L2CAPChannel, gdy zdalna strona go otworzy.

psm: Multiplekser protokołu/usługi (PSM), na którym należy nasłuchiwać.
mtu: Maksymalny rozmiar odbioru, w bajtach.
timeout_ms: Maksymalny czas oczekiwania na połączenie zdalnej strony.

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

Asynchroniczna. Otwiera kanał L2CAP do zdalnej strony na podanym PSM.

psm: Multiplekser protokołu/usługi (PSM), z którym należy się połączyć.
mtu: Maksymalny rozmiar odbioru, w bajtach.
timeout_ms: Limit czasu połączenia.

class aioble.ScanResult#

Pojedyncze urządzenie wykryte podczas scan. Ta sama instancja jest ponownie udostępniana w miarę napływania nowych danych rozgłaszania.

Nie należy tworzyć bezpośrednio.

device#: Leżące u podstaw urządzenie Device.

rssi#: Ostatnio zgłoszone RSSI, w dBm.

adv_data#: Surowy ładunek rozgłaszania (bytes lub None).

resp_data#: Surowy ładunek odpowiedzi na skanowanie (bytes lub None), jeśli włączone jest skanowanie aktywne.

connectable#: True, jeśli najnowsze rozgłaszanie umożliwiało połączenie.

name() → str | None#: Dekoduje pełną (lub skróconą) rozgłaszaną nazwę lokalną z ładunku lub None, jeśli nie jest obecna.

services() → Iterator[bluetooth.UUID]#: Generator udostępniający każdy bluetooth.UUID rozgłaszany w polach listy usług 16/32/128-bitowych.

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

Generator udostępniający krotki (company_id, data) z pól rozgłaszania specyficznych dla producenta.

filter: Jeśli podany, udostępnia tylko wpisy, których ID producenta pasuje.

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

Lokalna usługa GATT. Zbuduj usługę z jedną lub więcej instancjami Characteristic, a następnie przekaż ją do register_services.

uuid: UUID usługi.

uuid#: UUID usługi.

characteristics#: Lista obiektów Characteristic powiązanych z tą usługą.

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

Lokalna charakterystyka GATT. Utworzenie jej automatycznie dołącza ją do service.

service: Usługa Service, do której należy.
uuid: UUID charakterystyki.
read, write, write_no_response, notify, indicate: Wartości logiczne wybierające obsługiwane operacje GATT.
initial: Opcjonalna wartość początkowa (bytes).
capture: Jeśli True, zapisane wartości są kolejkowane (do 10 w głąb), aby szybkie, następujące po sobie zapisy nie zostały utracone. Każde wywołanie written zwraca wtedy krotkę (connection, data).

uuid#: UUID charakterystyki.

flags#: Maska bitowa flag właściwości GATT zbudowana na podstawie konstruktora.

descriptors#: Lista obiektów Descriptor powiązanych z tą charakterystyką.

read() → bytes#: Odczytuje bieżącą wartość z lokalnej bazy danych GATT.

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

Aktualizuje wartość w lokalnej bazie danych GATT.

data: Nowe bajty wartości.
send_update: Jeśli True, dodatkowo powiadamia/indykuje każde subskrybowane połączenie.

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

Wysyła powiadomienie GATT (Notify) do connection.

connection: Docelowe połączenie klienta.
data: Ładunek do wysłania. Jeśli None, wysyłana jest bieżąca wartość lokalna.

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

Asynchroniczna. Wysyła indykację GATT (Indicate) do connection i czeka na potwierdzenie klienta. Zgłasza GattError przy statusie niezerowym.

connection: Docelowe połączenie klienta.
data: Ładunek do indykacji lub None, aby wysłać wartość lokalną.
timeout_ms: Maksymalny czas oczekiwania na potwierdzenie.

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

Asynchroniczna. Oczekuje na zdalny zapis. Zwraca zapisujące DeviceConnection lub (connection, data), jeśli charakterystyka została utworzona z capture=True.

timeout_ms: Maksymalny czas oczekiwania. None oznacza oczekiwanie w nieskończoność.

on_read(connection: DeviceConnection) → int#: Punkt przesłonięcia (override hook) wywoływany synchronicznie po otrzymaniu zdalnego odczytu. Zwróć 0, aby zezwolić na odczyt, lub niezerowy kod błędu ATT, aby go odrzucić. Domyślna implementacja zwraca 0.

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

Charakterystyka Characteristic, której bufor GATT można skonfigurować. Przydatna do odbierania wartości większych niż domyślny rozmiar atrybutu lub do kolejkowania następujących po sobie zapisów.

max_len: Rozmiar bufora, w bajtach.
append: Jeśli True, kolejne zapisy są dopisywane do bufora zamiast nadpisywania.

Pozostałe argumenty są przekazywane do Characteristic.

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

Lokalny deskryptor GATT. Utworzenie go automatycznie dołącza go do characteristic. Dziedziczy read, write oraz written z Characteristic.

characteristic: Charakterystyka Characteristic, do której należy.
uuid: UUID deskryptora.
read, write: Wartości logiczne wybierające obsługiwane operacje GATT.
initial: Opcjonalna wartość początkowa (bytes).

class aioble.ClientService#

Zdalna usługa GATT wykryta na urządzeniu równorzędnym (peer). Zwracana przez DeviceConnection.service() lub iterowana z DeviceConnection.services().

Nie należy tworzyć bezpośrednio.

connection#: Połączenie DeviceConnection, do którego należy.

uuid#: UUID zdalnej usługi.

characteristic(uuid: bluetooth.UUID, timeout_ms: int = 2000) → Awaitable[ClientCharacteristic | None]#: Asynchroniczna. Wykrywa pojedynczą charakterystykę po UUID lub None, jeśli nie zostanie znaleziona.

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

Zwraca asynchroniczny iterator obiektów ClientCharacteristic. Używaj z async for i wykonaj pętlę do końca.

uuid: Opcjonalny filtr UUID.
timeout_ms: Limit czasu na wykrycie.

class aioble.ClientCharacteristic#

Zdalna charakterystyka GATT wykryta na urządzeniu równorzędnym (peer). Zwracana przez ClientService.characteristic() lub iterowana z ClientService.characteristics().

Nie należy tworzyć bezpośrednio.

service#: Usługa ClientService, do której należy.

uuid#: UUID charakterystyki.

properties#: Maska bitowa obsługiwanych operacji GATT zgłoszonych przez urządzenie równorzędne.

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

Asynchroniczna. Wykonuje odczyt GATT (Read) i zwraca wartość. Zgłasza GattError przy statusie niezerowym.

timeout_ms: Limit czasu odczytu.

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

Asynchroniczna. Wykonuje zapis GATT (Write).

data: Wartość do zapisania.
response: True, aby wymagać odpowiedzi na zapis (i zgłosić GattError w razie niepowodzenia). False dla zapisu bez odpowiedzi. None (domyślnie) automatycznie wybiera na podstawie tego, co rozgłasza urządzenie równorzędne.
timeout_ms: Limit czasu zapisu (istotny tylko, jeśli response ma wartość True).

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

Asynchroniczna. Oczekuje na następne powiadomienie dla tej charakterystyki i zwraca jego ładunek. Zwraca natychmiast, jeśli powiadomienie jest już zakolejkowane.

timeout_ms: Maksymalny czas oczekiwania. None oznacza oczekiwanie w nieskończoność.

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

Asynchroniczna. Oczekuje na następną indykację dla tej charakterystyki i zwraca jej ładunek.

timeout_ms: Maksymalny czas oczekiwania.

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

Asynchroniczna. Zapisuje Client Characteristic Configuration Descriptor (CCCD), aby zasubskrybować (lub anulować subskrypcję) powiadomień i/lub indykacji.

notify: Włącz powiadomienia.
indicate: Włącz indykacje.

descriptor(uuid: bluetooth.UUID, timeout_ms: int = 2000) → Awaitable[ClientDescriptor | None]#: Asynchroniczna. Wykrywa pojedynczy deskryptor po UUID lub None, jeśli nie zostanie znaleziony.

descriptors(timeout_ms: int = 2000) → ClientDiscover#: Zwraca asynchroniczny iterator obiektów ClientDescriptor. Używaj z async for i wykonaj pętlę do końca.

class aioble.ClientDescriptor#

Zdalny deskryptor GATT wykryty na urządzeniu równorzędnym (peer). Dziedziczy read oraz write z ClientCharacteristic.

Nie należy tworzyć bezpośrednio.

characteristic#: Charakterystyka ClientCharacteristic, do której należy.

uuid#: UUID deskryptora.

class aioble.L2CAPChannel#

Aktywny połączeniowy kanał L2CAP. Zwracany przez DeviceConnection.l2cap_accept() lub DeviceConnection.l2cap_connect(). Obsługuje użycie jako menedżer kontekstu async with automatycznie rozłączający się przy wyjściu.

Nie należy tworzyć bezpośrednio.

our_mtu#: Maksymalny rozmiar, w bajtach, jaki urządzenie równorzędne może wysłać do nas w pojedynczym SDU.

peer_mtu#: Maksymalny rozmiar, w bajtach, jaki możemy wysłać do urządzenia równorzędnego w pojedynczym SDU.

available() → bool#: Zwraca synchronicznie True, jeśli zbuforowane dane odbiorcze są gotowe (tzn. recvinto nie zablokuje wykonania).

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

Asynchroniczna. Odbiera do buf, zwracając liczbę odczytanych bajtów. Oczekuje na nowe dane, jeśli kanał jest pusty.

buf: Wstępnie przydzielony bufor do wypełnienia.
timeout_ms: Maksymalny czas oczekiwania. None oznacza oczekiwanie w nieskończoność.

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

Asynchroniczna. Wysyła buf na kanale, fragmentując większe ładunki na fragmenty o rozmiarze MTU. Oczekuje na kredyty kontroli przepływu w razie potrzeby.

buf: Obiekt typu bytes-like do wysłania.
timeout_ms: Maksymalny czas oczekiwania na fragment.
chunk_size: Opcjonalne przesłonięcie rozmiaru fragmentu na wywołanie. Ograniczone do min(our_mtu * 2, peer_mtu).

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

Asynchroniczna. Oczekuje, aż wszelkie zatrzymane send zostaną opróżnione przez kontroler.

timeout_ms: Maksymalny czas oczekiwania.

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

Asynchroniczna. Rozłącza kanał i czeka na przerwanie (IRQ) rozłączenia.

timeout_ms: Maksymalny czas oczekiwania.

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

Asynchroniczna. Oczekuje, aż kanał zostanie rozłączony przez którąkolwiek ze stron.

timeout_ms: Maksymalny czas oczekiwania.

aioble — Asynchroniczne BLE#

Przykłady#

Funkcje na poziomie modułu#

Stałe na poziomie modułu#

Wyjątki#

Klasy#

`aioble` — Asynchroniczne BLE#