`aioble` — Async BLE#

aioble ist ein asyncio-freundlicher High-Level-Wrapper um das bluetooth-Modul. Es stellt saubere Coroutinen für Scannen, Verbinden, Werben (Advertising), GATT-Dienste und L2CAP-Kanäle bereit.

Alle Remote-Operationen (connect, disconnect, Client read/write, Server indicate, l2cap recv/send, pair) sind awaitable und unterstützen Timeouts.

Unterstützte Rollen:

Broadcaster (Advertiser) — erzeugt Advertising- und Scan-Response-Nutzdaten für gängige Felder, teilt die Nutzdaten automatisch auf Advertising und Scan Response auf und wirbt unbegrenzt oder für eine feste Dauer.
Peripheral — wartet auf eine Verbindung von einem Central und wartet auf den MTU-Austausch.
Observer (Scanner) — passives und aktives Scannen, kombiniert Advertising- und Scan-Response-Nutzdaten für dasselbe Gerät und parst gängige Felder aus Advertising-Nutzdaten.
Central — verbindet sich mit einem Peripheral und initiiert den MTU-Austausch.
GATT Client — ermittelt Dienste / Charakteristiken / Deskriptoren (optional nach UUID); read / write / write-with-response für Charakteristiken und Deskriptoren; abonniert Notifications und Indications (über das CCCD); wartet auf Notifications und Indications.
GATT Server — registriert Dienste / Charakteristiken / Deskriptoren; wartet auf Schreibvorgänge an Charakteristiken und Deskriptoren; fängt Leseanfragen ab; sendet Notifications und Indications (und wartet auf die Antwort).
L2CAP — akzeptiert und verbindet verbindungsorientierte L2CAP-Kanäle und verwaltet die Flusskontrolle des Kanals.
Sicherheit — JSON-gestützte Schlüssel-/Geheimnisverwaltung, initiiert das Pairing, fragt den Verschlüsselungs-/Authentifizierungsstatus ab.

Beispiele#

Nach BLE-Geräten in der Nähe scannen und jedes anzeigen, sobald es erkannt wird:

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

Sich als Central mit einem Peripheral verbinden, das den Heart-Rate-Dienst bewirbt, und seine Mess-Notifications abonnieren:

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

Als Peripheral agieren: einen GATT-Dienst registrieren, ihn bewerben und Notifications an alle senden, die sich verbinden:

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

Funktionen auf Modulebene#

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

Leitet an bluetooth.BLE.config() weiter und stellt sicher, dass das BLE-Radio zuvor aktiv ist.

args: Optionaler einzelner Parametername, der abgefragt werden soll.
kwargs: Keyword-Argumente zum Setzen von Konfigurationswerten.

aioble.stop() → None#: Deaktiviert das zugrunde liegende BLE-Radio und führt alle registrierten Shutdown-Handler von Submodulen aus. Nach diesem Aufruf werden Scanner, Advertiser, Verbindungen und L2CAP-Kanäle allesamt abgebaut.

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

Gibt einen scan-Async-Context-Manager / Async-Iterator zurück, der für jedes eindeutig erkannte Gerät (oder für jedes neue Advertising-Datenpaket eines bekannten Geräts) eine ScanResult-Instanz liefert.

duration_ms: Wie lange gescannt werden soll, in Millisekunden. Übergeben Sie 0, um unbegrenzt zu scannen, bis der Context Manager beendet wird.
interval_us: Scan-Intervall in Mikrosekunden. Standardwert ist 1.280.000.
window_us: Scan-Fenster in Mikrosekunden (muss kleiner oder gleich interval_us sein). Standardwert ist 11.250.
active: Wenn True, wird ein aktiver Scan durchgeführt (Scan-Response-Daten werden angefordert). Standardwert ist 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#

Async-Coroutine, die mit dem Advertising beginnt und auf eine eingehende Central-Verbindung wartet. Gibt eine DeviceConnection zurück, die das verbundene Central repräsentiert, oder löst bei Timeout asyncio.TimeoutError aus.

interval_us: Advertising-Intervall, in Mikrosekunden.
adv_data: Rohe Advertising-Nutzdaten. Wenn nicht gesetzt, werden adv_data aus den übrigen Keyword-Argumenten erstellt.
resp_data: Rohe Scan-Response-Nutzdaten. Wird bei Bedarf automatisch mit dem Überlauf aus adv_data befüllt.
connectable: Wenn True, handelt es sich um eine verbindbare Werbung (Advertisement).
limited_disc: Verwendet das Limited-Discoverable-Flag anstelle von General.
br_edr: Setzt das BR/EDR-Supported-Flag.
name: Optionaler vollständiger lokaler Name, der eingebettet werden soll.
services: Iterable von bluetooth.UUID, die beworben werden sollen.
appearance: 16-Bit-Appearance-Wert (siehe Bluetooth Assigned Numbers).
manufacturer: Tupel aus (company_id, data_bytes), das als herstellerspezifische Daten beworben werden soll.
timeout_ms: Stoppt das Advertising nach dieser Anzahl von Millisekunden ohne Verbindung. None bedeutet, bis zur Verbindung zu werben.

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

Registriert ein oder mehrere Service-Objekte (und ihre Charakteristiken und Deskriptoren) beim GATT-Server. Muss einmal aufgerufen werden, bevor advertise gestartet wird. Nachfolgende Aufrufe ersetzen die vorherige Registrierung.

services: Eine oder mehrere Service-Instanzen.

Konstanten auf Modulebene#

aioble.ADDR_PUBLIC#: Öffentlicher BLE-Geräteadresstyp (0).

aioble.ADDR_RANDOM#: Zufälliger BLE-Geräteadresstyp (1).

Ausnahmen#

exception aioble.GattError#: Wird ausgelöst, wenn eine Remote-GATT-Operation (read / write / indicate) mit einem von null verschiedenen Status abgeschlossen wird. Der Statuscode ist über das Attribut _status verfügbar.

exception aioble.DeviceDisconnectedError#: Wird innerhalb einer Async-Operation (z. B. read, write, notified) ausgelöst, wenn die zugrunde liegende Verbindung während des Wartens abbricht.

exception aioble.L2CAPDisconnectedError#: Wird ausgelöst, wenn eine L2CAP-Kanaloperation send/recv/flush auf einem getrennten Kanal versucht (oder durch diesen unterbrochen) wird.

exception aioble.L2CAPConnectionError#: Wird von DeviceConnection.l2cap_connect ausgelöst, wenn das Einrichten des Kanals fehlschlägt. Der Bluetooth-Statuscode ist das erste Argument.

Klassen#

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

Repräsentiert ein Remote-BLE-Gerät anhand seiner Adresse. Zwei Device-Instanzen sind gleich, wenn sowohl addr_type als auch addr übereinstimmen. Wird als Handle zum Initiieren von Verbindungen verwendet.

addr_type: Entweder ADDR_PUBLIC oder ADDR_RANDOM.
addr: Sechs-Byte-Adresse als bytes oder ein durch Doppelpunkte getrennter Hex-String (z. B. "aa:bb:cc:dd:ee:ff").

addr_type#: Der Adresstyp, mit dem das Gerät erstellt wurde.

addr#: Die rohe Sechs-Byte-Geräteadresse.

addr_hex() → str#: Gibt die Adresse als durch Doppelpunkte getrennten Hex-String formatiert zurück.

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

Async. Initiiert eine GAP-Verbindung zu diesem Gerät und gibt die resultierende DeviceConnection zurück. Bricht jeden laufenden Scan ab.

timeout_ms: Wie lange auf den Abschluss der Verbindung gewartet werden soll.
scan_duration_ms: Anfängliche Scan-Dauer vor dem Verbinden (controllerspezifisch).
min_conn_interval_us / max_conn_interval_us: Optionale Grenzen für das Verbindungsintervall, in Mikrosekunden.

class aioble.DeviceConnection#

Eine aktive GAP-Verbindung zu einem Device. Wird von Device.connect() oder advertise zurückgegeben. Unterstützt die Verwendung als async with-Context-Manager, der beim Verlassen automatisch trennt.

Nicht direkt konstruieren.

device#: Das zugrunde liegende Device.

encrypted#: True, sobald der Link verschlüsselt ist (z. B. nach dem Pairing).

authenticated#: True, wenn der Link authentifiziert wurde (MITM-geschütztes Pair).

bonded#: True, wenn das Pairing Bonding-Schlüssel erzeugt hat.

key_size#: Ausgehandelte Verschlüsselungsschlüsselgröße in Bytes oder False, wenn nicht verschlüsselt.

mtu#: Ausgehandelte ATT-MTU nach exchange_mtu oder None, bis sie gesetzt ist.

is_connected() → bool#: Gibt zurück, ob die Verbindung noch aktiv ist.

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

Async. Trennt die Verbindung und wartet auf den Disconnection-IRQ.

timeout_ms: Maximale Wartezeit auf die Trennung.

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

Async. Wartet darauf, dass die Verbindung von einer der beiden Seiten beendet wird. Wenn disconnect True ist, wird zuvor aktiv getrennt.

timeout_ms: Maximale Wartezeit. None bedeutet, unbegrenzt zu warten.
disconnect: Wenn True, wird die Trennung initiiert.

timeout(timeout_ms: int | None) → DeviceTimeout#

Gibt einen Context Manager zurück, der seinen Rumpf abbricht, wenn entweder das Timeout abläuft (löst asyncio.TimeoutError aus) oder das Gerät die Verbindung trennt (löst DeviceDisconnectedError aus).

timeout_ms: Timeout in Millisekunden oder None für kein Timeout.

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

Async. Initiiert einen ATT-MTU-Austausch und gibt die ausgehandelte MTU zurück.

mtu: Optionale bevorzugte MTU, die vor dem Austausch auf der zugrunde liegenden BLE-Schnittstelle gesetzt werden soll.
timeout_ms: Timeout für den Austausch.

service(uuid: bluetooth.UUID, timeout_ms: int = 2000) → Awaitable[ClientService | None]#: Async. Ermittelt einen einzelnen Remote-Dienst, der zu uuid passt, oder None, falls nicht gefunden.

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

Gibt einen Async-Iterator von Remote-ClientService-Objekten zurück. Mit async for verwenden und die Schleife vollständig durchlaufen.

uuid: Optionaler UUID-Filter. None gibt jeden Dienst zurück.
timeout_ms: Timeout pro Discovery.

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

Async. Initiiert das Pairing auf dieser Verbindung. Aktualisiert nach Abschluss die Attribute encrypted / authenticated / bonded / key_size.

bond: Pairing-Schlüssel dauerhaft speichern.
le_secure: LE Secure Connections verwenden.
mitm: Man-in-the-Middle-Schutz erfordern.
io: IO-Capability-Konstante (z. B. 3 für kein Input/Output).
timeout_ms: Pairing-Timeout.

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

Async. Lauscht am angegebenen PSM und gibt einen L2CAPChannel zurück, sobald die Gegenstelle ihn öffnet.

psm: Protocol/Service Multiplexer, auf dem gelauscht werden soll.
mtu: Maximale Empfangsgröße, in Bytes.
timeout_ms: Maximale Wartezeit, bis sich die Gegenstelle verbindet.

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

Async. Öffnet einen L2CAP-Kanal zur Gegenstelle am angegebenen PSM.

psm: Protocol/Service Multiplexer, mit dem verbunden werden soll.
mtu: Maximale Empfangsgröße, in Bytes.
timeout_ms: Verbindungs-Timeout.

class aioble.ScanResult#

Ein einzelnes während scan erkanntes Gerät. Dieselbe Instanz wird erneut geliefert, sobald neue Advertising-Daten eintreffen.

Nicht direkt konstruieren.

device#: Das zugrunde liegende Device.

rssi#: Zuletzt gemeldeter RSSI, in dBm.

adv_data#: Rohe Advertising-Nutzdaten (bytes oder None).

resp_data#: Rohe Scan-Response-Nutzdaten (bytes oder None), falls aktives Scannen aktiviert ist.

connectable#: True, wenn die jüngste Werbung verbindbar war.

name() → str | None#: Dekodiert den vollständigen (oder verkürzten) beworbenen lokalen Namen aus den Nutzdaten oder None, falls nicht vorhanden.

services() → Iterator[bluetooth.UUID]#: Generator, der jede bluetooth.UUID liefert, die in den 16/32/128-Bit-Service-List-Feldern beworben wird.

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

Generator, der (company_id, data)-Tupel aus den herstellerspezifischen Advertising-Feldern liefert.

filter: Wenn angegeben, werden nur Einträge geliefert, deren Company-ID übereinstimmt.

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

Ein lokaler GATT-Dienst. Erstellen Sie einen Dienst mit einer oder mehreren Characteristic-Instanzen und übergeben Sie ihn dann an register_services.

uuid: Die Dienst-UUID.

uuid#: Die Dienst-UUID.

characteristics#: Liste der an diesen Dienst gebundenen Characteristic-Objekte.

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

Eine lokale GATT-Charakteristik. Beim Konstruieren wird sie automatisch an service angehängt.

service: Der besitzende Service.
uuid: Die Charakteristik-UUID.
read, write, write_no_response, notify, indicate: Booleans, die die unterstützten GATT-Operationen auswählen.
initial: Optionaler Anfangswert (bytes).
capture: Wenn True, werden geschriebene Werte in eine Warteschlange gestellt (bis zu 10 tief), damit rasch aufeinanderfolgende Schreibvorgänge nicht verloren gehen. Jeder written-Aufruf gibt dann ein (connection, data)-Tupel zurück.

uuid#: Die Charakteristik-UUID.

flags#: Bitmaske der GATT-Property-Flags, die aus dem Konstruktor aufgebaut wird.

descriptors#: Liste der an diese Charakteristik gebundenen Descriptor-Objekte.

read() → bytes#: Liest den aktuellen Wert aus der lokalen GATT-Datenbank.

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

Aktualisiert den Wert in der lokalen GATT-Datenbank.

data: Neue Wertbytes.
send_update: Wenn True, wird zusätzlich jede abonnierte Verbindung benachrichtigt (notify/indicate).

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

Sendet ein GATT Notify an connection.

connection: Die Ziel-Client-Verbindung.
data: Zu sendende Nutzdaten. Wenn None, wird der aktuelle lokale Wert gesendet.

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

Async. Sendet ein GATT Indicate an connection und wartet auf die Bestätigung des Clients. Löst bei einem von null verschiedenen Status GattError aus.

connection: Die Ziel-Client-Verbindung.
data: Zu meldende Nutzdaten oder None, um den lokalen Wert zu senden.
timeout_ms: Maximale Wartezeit auf die Bestätigung.

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

Async. Wartet auf einen Remote-Schreibvorgang. Gibt die schreibende DeviceConnection zurück oder (connection, data), falls die Charakteristik mit capture=True erstellt wurde.

timeout_ms: Maximale Wartezeit. None wartet unbegrenzt.

on_read(connection: DeviceConnection) → int#: Override-Hook, der synchron aufgerufen wird, wenn ein Remote-Read empfangen wird. Geben Sie 0 zurück, um den Read zuzulassen, oder einen von null verschiedenen ATT-Fehlercode, um ihn abzulehnen. Die Standardimplementierung gibt 0 zurück.

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

Eine Characteristic, deren zugrunde liegender GATT-Puffer konfiguriert werden kann. Nützlich für den Empfang von Werten, die größer als die Standard-Attributgröße sind, oder zum Einreihen aufeinanderfolgender Schreibvorgänge.

max_len: Puffergröße, in Bytes.
append: Wenn True, hängen aufeinanderfolgende Schreibvorgänge an den Puffer an, statt ihn zu überschreiben.

Weitere Argumente werden an Characteristic weitergeleitet.

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

Ein lokaler GATT-Deskriptor. Beim Konstruieren wird er automatisch an characteristic angehängt. Erbt read, write und written von Characteristic.

characteristic: Die besitzende Characteristic.
uuid: Die Deskriptor-UUID.
read, write: Booleans, die die unterstützten GATT-Operationen auswählen.
initial: Optionaler Anfangswert (bytes).

class aioble.ClientService#

Ein auf einer Gegenstelle erkannter Remote-GATT-Dienst. Wird von DeviceConnection.service() zurückgegeben oder über DeviceConnection.services() iteriert.

Nicht direkt konstruieren.

connection#: Die besitzende DeviceConnection.

uuid#: Die Remote-Dienst-UUID.

characteristic(uuid: bluetooth.UUID, timeout_ms: int = 2000) → Awaitable[ClientCharacteristic | None]#: Async. Ermittelt eine einzelne Charakteristik nach UUID oder None, falls nicht gefunden.

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

Gibt einen Async-Iterator von ClientCharacteristic-Objekten zurück. Mit async for verwenden und die Schleife vollständig durchlaufen.

uuid: Optionaler UUID-Filter.
timeout_ms: Timeout pro Discovery.

class aioble.ClientCharacteristic#

Eine auf einer Gegenstelle erkannte Remote-GATT-Charakteristik. Wird von ClientService.characteristic() zurückgegeben oder über ClientService.characteristics() iteriert.

Nicht direkt konstruieren.

service#: Der besitzende ClientService.

uuid#: Die Charakteristik-UUID.

properties#: Bitmaske der unterstützten GATT-Operationen, wie von der Gegenstelle gemeldet.

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

Async. Führt ein GATT Read aus und gibt den Wert zurück. Löst bei einem von null verschiedenen Status GattError aus.

timeout_ms: Lese-Timeout.

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

Async. Führt ein GATT Write aus.

data: Zu schreibender Wert.
response: True, um eine Write-Response zu erfordern (und bei Fehlschlag GattError auszulösen). False für Write-without-Response. None (Standard) wählt automatisch anhand dessen, was die Gegenstelle bewirbt.
timeout_ms: Schreib-Timeout (nur relevant, wenn response True ist).

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

Async. Wartet auf die nächste Notification an dieser Charakteristik und gibt deren Nutzdaten zurück. Kehrt sofort zurück, wenn bereits eine Notification in der Warteschlange steht.

timeout_ms: Maximale Wartezeit. None wartet unbegrenzt.

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

Async. Wartet auf die nächste Indication an dieser Charakteristik und gibt deren Nutzdaten zurück.

timeout_ms: Maximale Wartezeit.

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

Async. Schreibt den Client Characteristic Configuration Descriptor (CCCD), um Notifications und/oder Indications zu abonnieren (oder abzubestellen).

notify: Notifications aktivieren.
indicate: Indications aktivieren.

descriptor(uuid: bluetooth.UUID, timeout_ms: int = 2000) → Awaitable[ClientDescriptor | None]#: Async. Ermittelt einen einzelnen Deskriptor nach UUID oder None, falls nicht gefunden.

descriptors(timeout_ms: int = 2000) → ClientDiscover#: Gibt einen Async-Iterator von ClientDescriptor-Objekten zurück. Mit async for verwenden und die Schleife vollständig durchlaufen.

class aioble.ClientDescriptor#

Ein auf einer Gegenstelle erkannter Remote-GATT-Deskriptor. Erbt read und write von ClientCharacteristic.

Nicht direkt konstruieren.

characteristic#: Die besitzende ClientCharacteristic.

uuid#: Die Deskriptor-UUID.

class aioble.L2CAPChannel#

Ein aktiver verbindungsorientierter L2CAP-Kanal. Wird von DeviceConnection.l2cap_accept() oder DeviceConnection.l2cap_connect() zurückgegeben. Unterstützt die Verwendung als async with-Context-Manager, der beim Verlassen automatisch trennt.

Nicht direkt konstruieren.

our_mtu#: Maximale Größe, in Bytes, die die Gegenstelle uns in einer einzelnen SDU senden darf.

peer_mtu#: Maximale Größe, in Bytes, die wir der Gegenstelle in einer einzelnen SDU senden dürfen.

available() → bool#: Gibt synchron True zurück, wenn gepufferte Empfangsdaten bereit sind (d. h. recvinto nicht blockiert).

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

Async. Empfängt in buf und gibt die Anzahl der gelesenen Bytes zurück. Wartet auf neue Daten, wenn der Kanal leer ist.

buf: Vorab allokierter Puffer, der gefüllt werden soll.
timeout_ms: Maximale Wartezeit. None wartet unbegrenzt.

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

Async. Sendet buf auf dem Kanal und fragmentiert größere Nutzdaten in MTU-große Stücke. Wartet bei Bedarf auf Flusskontroll-Credits.

buf: Bytes-ähnliches Objekt, das gesendet werden soll.
timeout_ms: Maximale Wartezeit pro Stück.
chunk_size: Optionale Überschreibung der Stückgröße pro Aufruf. Begrenzt auf min(our_mtu * 2, peer_mtu).

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

Async. Wartet, bis ein blockiertes send vom Controller abgearbeitet wurde.

timeout_ms: Maximale Wartezeit.

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

Async. Trennt den Kanal und wartet auf den Disconnection-IRQ.

timeout_ms: Maximale Wartezeit.

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

Async. Wartet, bis der Kanal von einer der beiden Seiten getrennt wird.

timeout_ms: Maximale Wartezeit.

aioble — Async BLE#

Beispiele#

Funktionen auf Modulebene#

Konstanten auf Modulebene#

Ausnahmen#

Klassen#

`aioble` — Async BLE#