`aioble` — Asenkron BLE#

aioble, bluetooth modülünün etrafına yazılmış üst düzey, asyncio uyumlu bir sarmalayıcıdır. Tarama, bağlanma, reklam yayını, GATT hizmetleri ve L2CAP kanalları için temiz coroutine’ler sağlar.

Tüm uzak işlemler (connect, disconnect, istemci read/write, sunucu indicate, l2cap recv/send, pair) beklenebilir (awaitable) niteliktedir ve zaman aşımlarını destekler.

Desteklenen roller:

Yayıncı (advertiser) — yaygın alanlar için reklam ve tarama yanıtı yükleri üretir, yükü reklam ve tarama yanıtı arasında otomatik olarak böler, süresiz olarak veya sabit bir süre boyunca reklam yayını yapar.
Çevre birimi (Peripheral) — bir merkezden (central) bağlantı bekler, MTU değişimini bekler.
Gözlemci (scanner) — pasif ve aktif tarama, aynı cihaz için reklam ve tarama yanıtı yüklerini birleştirir, reklam yüklerinden yaygın alanları ayrıştırır.
Merkez (Central) — bir çevre birimine bağlanır, MTU değişimini başlatır.
GATT İstemcisi — hizmetleri / özellikleri / tanımlayıcıları keşfeder (isteğe bağlı olarak UUID’ye göre); özellikler ve tanımlayıcılar üzerinde read / write / write-with-response yapar; bildirimlere ve göstergelere abone olur (CCCD aracılığıyla); bildirimleri ve göstergeleri bekler.
GATT Sunucusu — hizmetleri / özellikleri / tanımlayıcıları kaydeder; özellikler ve tanımlayıcılar üzerindeki yazmaları bekler; okuma isteklerini yakalar; bildirimleri ve göstergeleri gönderir (ve yanıtı bekler).
L2CAP — bağlantı odaklı L2CAP kanallarını kabul eder ve bağlar, kanal akış denetimini yönetir.
Güvenlik — JSON tabanlı anahtar/gizli yönetimi, eşleştirme başlatma, şifreleme / kimlik doğrulama durumunu sorgulama.

Örnekler#

Yakındaki BLE cihazlarını tarayın ve görüldükçe her birini yazdırın:

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

Bir merkez (central) olarak Heart Rate hizmetinin reklamını yapan bir çevre birimine bağlanın ve ölçüm bildirimlerine abone olun:

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

Bir çevre birimi (peripheral) olarak hareket edin: bir GATT hizmeti kaydedin, reklamını yapın ve bağlanan herkese bildirim gönderin:

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

Modül düzeyindeki fonksiyonlar#

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

bluetooth.BLE.config() çağrısına yönlendirir ve önce BLE radyosunun etkin olduğundan emin olur.

args: Sorgulanacak isteğe bağlı tek parametre adı.
kwargs: Yapılandırma değerlerini ayarlamak için anahtar sözcük argümanları.

aioble.stop() → None#: Temel BLE radyosunu devre dışı bırakır ve kayıtlı tüm alt modül kapatma işleyicilerini çalıştırır. Bu çağrıdan sonra tarayıcılar, reklam yayıncıları, bağlantılar ve L2CAP kanallarının tamamı sonlandırılır.

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

Keşfedilen her benzersiz cihaz için (veya bilinen bir cihazdan gelen her yeni reklam verisi parçası için) ScanResult örnekleri üreten bir scan asenkron bağlam yöneticisi / asenkron yineleyici döndürür.

duration_ms: Milisaniye cinsinden taramanın ne kadar süreceği. Bağlam yöneticisi çıkana kadar süresiz tarama yapmak için 0 geçirin.
interval_us: Mikrosaniye cinsinden tarama aralığı. Varsayılan değer 1.280.000’dir.
window_us: Mikrosaniye cinsinden tarama penceresi (interval_us değerine eşit veya daha küçük olmalıdır). Varsayılan değer 11.250’dir.
active: True ise, aktif bir tarama gerçekleştirir (tarama yanıt verisi ister). Varsayılan değer False şeklindedir.

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#

Reklam yayınını başlatan ve gelen bir merkez bağlantısını bekleyen asenkron coroutine. Bağlı merkezi temsil eden bir DeviceConnection döndürür veya zaman aşımında asyncio.TimeoutError yükseltir.

interval_us: Mikrosaniye cinsinden reklam aralığı.
adv_data: Ham reklam yükü. Ayarlanmamışsa, adv_data kalan anahtar sözcük argümanlarından oluşturulur.
resp_data: Ham tarama yanıtı yükü. Gerekirse adv_data taşmasından otomatik olarak doldurulur.
connectable: True ise, bu bağlanabilir bir reklamdır.
limited_disc: Genel yerine sınırlı keşfedilebilir (limited-discoverable) bayrağını kullanır.
br_edr: BR/EDR-destekli bayrağını ayarlar.
name: Gömülecek isteğe bağlı tam yerel ad.
services: Reklamı yapılacak bluetooth.UUID yinelenebiliri.
appearance: 16-bit görünüm değeri (bkz. Bluetooth atanmış numaralar).
manufacturer: Üreticiye özgü veri olarak reklamı yapılacak (company_id, data_bytes) demeti.
timeout_ms: Bağlantı olmadan bu kadar milisaniye sonra reklam yayınını durdurur. None, bağlanana kadar reklam yapılacağı anlamına gelir.

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

GATT sunucusuna bir veya daha fazla Service nesnesini (ve bunların özelliklerini ve tanımlayıcılarını) kaydeder. advertise başlatılmadan önce bir kez çağrılmalıdır. Sonraki çağrılar önceki kaydı değiştirir.

services: Bir veya daha fazla Service örneği.

Modül düzeyindeki sabitler#

aioble.ADDR_PUBLIC#: Genel (Public) BLE cihaz adres tipi (0).

aioble.ADDR_RANDOM#: Rastgele (Random) BLE cihaz adres tipi (1).

İstisnalar#

exception aioble.GattError#: Uzak bir GATT işlemi (read / write / indicate) sıfır olmayan bir durumla tamamlandığında yükseltilir. Durum kodu _status özniteliği üzerinden erişilebilir.

exception aioble.DeviceDisconnectedError#: Bir asenkron işlem (örn. read, write, notified) içinde, beklerken temel bağlantı kesildiğinde yükseltilir.

exception aioble.L2CAPDisconnectedError#: Bağlantısı kesilmiş bir kanal üzerinde (veya bunun tarafından kesintiye uğratılarak) bir L2CAP kanal send/recv/flush işlemi denendiğinde yükseltilir.

exception aioble.L2CAPConnectionError#: Kanal kurulumu başarısız olduğunda DeviceConnection.l2cap_connect tarafından yükseltilir. İlk argüman Bluetooth durum kodudur.

Sınıflar#

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

Uzak bir BLE cihazını adresine göre temsil eder. İki Device örneği, hem addr_type hem de addr eşleşiyorsa eşit kabul edilir. Bağlantıları başlatmak için tanıtıcı (handle) olarak kullanılır.

addr_type: ADDR_PUBLIC veya ADDR_RANDOM.
addr: bytes olarak altı baytlık adres veya iki nokta üst üste ile ayrılmış onaltılık bir dize (örn. "aa:bb:cc:dd:ee:ff").

addr_type#: Cihazın oluşturulduğu adres tipi.

addr#: Ham altı baytlık cihaz adresi.

addr_hex() → str#: Adresi iki nokta üst üste ile ayrılmış onaltılık bir dize olarak biçimlendirip döndürür.

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

Asenkron. Bu cihaza bir GAP bağlantısı başlatır ve elde edilen DeviceConnection nesnesini döndürür. Devam eden herhangi bir taramayı iptal eder.

timeout_ms: Bağlantının tamamlanmasının ne kadar bekleneceği.
scan_duration_ms: Bağlanmadan önceki ilk tarama süresi (denetleyiciye özgü).
min_conn_interval_us / max_conn_interval_us: Mikrosaniye cinsinden isteğe bağlı bağlantı aralığı sınırları.

class aioble.DeviceConnection#

Bir Device ile etkin bir GAP bağlantısı. Device.connect() veya advertise tarafından döndürülür. Çıkışta otomatik olarak bağlantıyı kesen bir async with bağlam yöneticisi olarak kullanımı destekler.

Doğrudan oluşturmayın.

device#: Temel Device.

encrypted#: Bağlantı şifrelendikten sonra (örn. eşleştirme sonrası) True olur.

authenticated#: Bağlantı kimliği doğrulanmışsa (MITM korumalı eşleştirme) True olur.

bonded#: Eşleştirme bağlanma (bonding) anahtarları ürettiyse True olur.

key_size#: Bayt cinsinden anlaşılan şifreleme anahtarı boyutu veya şifrelenmemişse False.

mtu#: exchange_mtu sonrasında anlaşılan ATT MTU veya ayarlanana kadar None.

is_connected() → bool#: Bağlantının hâlâ etkin olup olmadığını döndürür.

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

Asenkron. Bağlantıyı keser ve bağlantı kesme IRQ’sunu bekler.

timeout_ms: Bağlantı kesmenin beklenmesi için maksimum süre.

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

Asenkron. Bağlantının iki taraftan biri tarafından sonlandırılmasını bekler. disconnect True ise önce etkin olarak bağlantıyı keser.

timeout_ms: Maksimum bekleme süresi. None, sonsuza kadar bekleme anlamına gelir.
disconnect: True ise, bağlantı kesmeyi başlatır.

timeout(timeout_ms: int | None) → DeviceTimeout#

Ya zaman aşımı dolarsa (asyncio.TimeoutError yükselterek) ya da cihazın bağlantısı kesilirse (DeviceDisconnectedError yükselterek) gövdesini iptal eden bir bağlam yöneticisi döndürür.

timeout_ms: Milisaniye cinsinden zaman aşımı veya zaman aşımı olmaması için None.

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

Asenkron. Bir ATT MTU değişimi başlatır ve anlaşılan MTU’yu döndürür.

mtu: Değişimden önce temel BLE arabiriminde ayarlanacak isteğe bağlı tercih edilen MTU.
timeout_ms: Değişim için zaman aşımı.

service(uuid: bluetooth.UUID, timeout_ms: int = 2000) → Awaitable[ClientService | None]#: Asenkron. uuid ile eşleşen tek bir uzak hizmeti keşfeder veya bulunamazsa None döndürür.

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

Uzak ClientService nesnelerinin asenkron bir yineleyicisini döndürür. async for ile kullanın ve döngüyü sonuna kadar çalıştırın.

uuid: İsteğe bağlı UUID filtresi. None her hizmeti döndürür.
timeout_ms: Keşif başına zaman aşımı.

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

Asenkron. Bu bağlantıda eşleştirmeyi başlatır. Tamamlandığında encrypted / authenticated / bonded / key_size özniteliklerini günceller.

bond: Eşleştirme anahtarlarını kalıcı hale getirir.
le_secure: LE Secure Connections kullanır.
mitm: Ortadaki adam (man-in-the-middle) korumasını gerektirir.
io: IO yetenek sabiti (örn. giriş/çıkış olmaması için 3).
timeout_ms: Eşleştirme zaman aşımı.

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

Asenkron. Verilen PSM üzerinde dinler ve uzak taraf açtığında bir L2CAPChannel döndürür.

psm: Üzerinde dinlenecek Protocol/Service Multiplexer.
mtu: Bayt cinsinden maksimum alma boyutu.
timeout_ms: Uzak tarafın bağlanmasının beklenmesi için maksimum süre.

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

Asenkron. Verilen PSM üzerinde uzak tarafa bir L2CAP kanalı açar.

psm: Bağlanılacak Protocol/Service Multiplexer.
mtu: Bayt cinsinden maksimum alma boyutu.
timeout_ms: Bağlantı zaman aşımı.

class aioble.ScanResult#

scan sırasında keşfedilen tek bir cihaz. Yeni reklam verileri geldikçe aynı örnek yeniden üretilir.

Doğrudan oluşturmayın.

device#: Temel Device.

rssi#: dBm cinsinden son bildirilen RSSI.

adv_data#: Ham reklam yükü (bytes veya None).

resp_data#: Aktif tarama etkinse, ham tarama yanıtı yükü (bytes veya None).

connectable#: En son reklam bağlanabilir nitelikteyse True olur.

name() → str | None#: Yükten tam (veya kısaltılmış) reklamı yapılan yerel adı çözer veya yoksa None döndürür.

services() → Iterator[bluetooth.UUID]#: 16/32/128-bit hizmet listesi alanlarında reklamı yapılan her bluetooth.UUID değerini üreten bir üreteç (generator).

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

Üreticiye özgü reklam alanlarından (company_id, data) demetlerini üreten bir üreteç (generator).

filter: Verilirse, yalnızca şirket kimliği eşleşen girdileri üretir.

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

Yerel bir GATT hizmeti. Bir hizmeti bir veya daha fazla Characteristic örneğiyle oluşturun, ardından register_services fonksiyonuna geçirin.

uuid: Hizmet UUID’si.

uuid#: Hizmet UUID’si.

characteristics#: Bu hizmete bağlı Characteristic nesnelerinin listesi.

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

Yerel bir GATT özelliği. Bir tane oluşturmak, onu otomatik olarak service öğesine ekler.

service: Sahip olan Service.
uuid: Özellik UUID’si.
read, write, write_no_response, notify, indicate: Desteklenen GATT işlemlerini seçen mantıksal (Boolean) değerler.
initial: İsteğe bağlı başlangıç değeri (bytes).
capture: True ise, yazılan değerler kuyruğa alınır (en fazla 10 derinliğinde), böylece arka arkaya gelen hızlı yazmalar kaybolmaz. Her written çağrısı ardından bir (connection, data) demeti döndürür.

uuid#: Özellik UUID’si.

flags#: Kurucudan oluşturulan GATT özellik bayraklarının bit maskesi.

descriptors#: Bu özelliğe bağlı Descriptor nesnelerinin listesi.

read() → bytes#: Geçerli değeri yerel GATT veritabanından okur.

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

Yerel GATT veritabanındaki değeri günceller.

data: Yeni değer baytları.
send_update: True ise, ayrıca abone olan her bağlantıya bildirim/gösterge gönderir.

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

connection öğesine bir GATT Notify gönderir.

connection: Hedef istemci bağlantısı.
data: Gönderilecek yük. None ise, geçerli yerel değer gönderilir.

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

Asenkron. connection öğesine bir GATT Indicate gönderir ve istemci onayını bekler. Sıfır olmayan bir durumda GattError yükseltir.

connection: Hedef istemci bağlantısı.
data: Gösterilecek yük veya yerel değeri göndermek için None.
timeout_ms: Onayın beklenmesi için maksimum süre.

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

Asenkron. Uzak bir yazmayı bekler. Yazan DeviceConnection nesnesini veya özellik capture=True ile oluşturulduysa (connection, data) döndürür.

timeout_ms: Maksimum bekleme süresi. None sonsuza kadar bekler.

on_read(connection: DeviceConnection) → int#: Uzak bir okuma alındığında senkron olarak çağrılan geçersiz kılma (override) kancası. Okumaya izin vermek için 0 veya reddetmek için sıfır olmayan bir ATT hata kodu döndürür. Varsayılan uygulama 0 döndürür.

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

Arkaplandaki GATT arabelleği yapılandırılabilen bir Characteristic. Varsayılan öznitelik boyutundan daha büyük değerleri almak veya arka arkaya yazmaları kuyruğa almak için kullanışlıdır.

max_len: Bayt cinsinden arabellek boyutu.
append: True ise, ardışık yazmalar üzerine yazmak yerine arabelleğe eklenir.

Diğer argümanlar Characteristic öğesine iletilir.

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

Yerel bir GATT tanımlayıcısı. Bir tane oluşturmak, onu otomatik olarak characteristic öğesine ekler. Characteristic öğesinden read, write ve written yöntemlerini devralır.

characteristic: Sahip olan Characteristic.
uuid: Tanımlayıcı UUID’si.
read, write: Desteklenen GATT işlemlerini seçen mantıksal (Boolean) değerler.
initial: İsteğe bağlı başlangıç değeri (bytes).

class aioble.ClientService#

Bir eşte (peer) keşfedilen uzak bir GATT hizmeti. DeviceConnection.service() tarafından döndürülür veya DeviceConnection.services() üzerinden yinelenir.

Doğrudan oluşturmayın.

connection#: Sahip olan DeviceConnection.

uuid#: Uzak hizmet UUID’si.

characteristic(uuid: bluetooth.UUID, timeout_ms: int = 2000) → Awaitable[ClientCharacteristic | None]#: Asenkron. UUID’ye göre tek bir özelliği keşfeder veya bulunamazsa None döndürür.

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

ClientCharacteristic nesnelerinin asenkron bir yineleyicisini döndürür. async for ile kullanın ve döngüyü sonuna kadar çalıştırın.

uuid: İsteğe bağlı UUID filtresi.
timeout_ms: Keşif başına zaman aşımı.

class aioble.ClientCharacteristic#

Bir eşte (peer) keşfedilen uzak bir GATT özelliği. ClientService.characteristic() tarafından döndürülür veya ClientService.characteristics() üzerinden yinelenir.

Doğrudan oluşturmayın.

service#: Sahip olan ClientService.

uuid#: Özellik UUID’si.

properties#: Eş tarafından bildirilen, desteklenen GATT işlemlerinin bit maskesi.

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

Asenkron. Bir GATT Read gönderir ve değeri döndürür. Sıfır olmayan bir durumda GattError yükseltir.

timeout_ms: Okuma zaman aşımı.

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

Asenkron. Bir GATT Write gönderir.

data: Yazılacak değer.
response: Bir yazma yanıtı gerektirmek (ve başarısızlıkta GattError yükseltmek) için True. Yanıtsız yazma için False. None (varsayılan), eşin reklamını yaptığına göre otomatik seçer.
timeout_ms: Yazma zaman aşımı (yalnızca response True ise geçerlidir).

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

Asenkron. Bu özellikteki bir sonraki bildirimi bekler ve yükünü döndürür. Halihazırda kuyruğa alınmış bir bildirim varsa hemen döner.

timeout_ms: Maksimum bekleme süresi. None sonsuza kadar bekler.

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

Asenkron. Bu özellikteki bir sonraki göstergeyi bekler ve yükünü döndürür.

timeout_ms: Maksimum bekleme süresi.

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

Asenkron. Bildirimler ve/veya göstergeler için abone olmak (veya aboneliği kaldırmak) üzere Client Characteristic Configuration Descriptor (CCCD) öğesini yazar.

notify: Bildirimleri etkinleştirir.
indicate: Göstergeleri etkinleştirir.

descriptor(uuid: bluetooth.UUID, timeout_ms: int = 2000) → Awaitable[ClientDescriptor | None]#: Asenkron. UUID’ye göre tek bir tanımlayıcıyı keşfeder veya bulunamazsa None döndürür.

descriptors(timeout_ms: int = 2000) → ClientDiscover#: ClientDescriptor nesnelerinin asenkron bir yineleyicisini döndürür. async for ile kullanın ve döngüyü sonuna kadar çalıştırın.

class aioble.ClientDescriptor#

Bir eşte (peer) keşfedilen uzak bir GATT tanımlayıcısı. ClientCharacteristic öğesinden read ve write yöntemlerini devralır.

Doğrudan oluşturmayın.

characteristic#: Sahip olan ClientCharacteristic.

uuid#: Tanımlayıcı UUID’si.

class aioble.L2CAPChannel#

Etkin bir L2CAP bağlantı odaklı kanal. DeviceConnection.l2cap_accept() veya DeviceConnection.l2cap_connect() tarafından döndürülür. Çıkışta otomatik olarak bağlantıyı kesen bir async with bağlam yöneticisi olarak kullanımı destekler.

Doğrudan oluşturmayın.

our_mtu#: Eşin tek bir SDU içinde bize gönderebileceği bayt cinsinden maksimum boyut.

peer_mtu#: Tek bir SDU içinde eşe gönderebileceğimiz bayt cinsinden maksimum boyut.

available() → bool#: Arabelleğe alınmış alma verisi hazırsa (yani recvinto bloklamayacaksa) senkron olarak True döndürür.

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

Asenkron. buf içine alır ve okunan bayt sayısını döndürür. Kanal boşsa yeni veriyi bekler.

buf: Doldurulacak önceden ayrılmış arabellek.
timeout_ms: Maksimum bekleme süresi. None sonsuza kadar bekler.

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

Asenkron. buf öğesini kanalda gönderir, daha büyük yükleri MTU boyutundaki parçalara böler. Gerektiğinde akış denetimi kredilerini bekler.

buf: Gönderilecek bayt benzeri nesne.
timeout_ms: Parça başına maksimum bekleme süresi.
chunk_size: Çağrı başına parça boyutu için isteğe bağlı geçersiz kılma. min(our_mtu * 2, peer_mtu) ile sınırlandırılır.

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

Asenkron. Duraklamış herhangi bir send işlemi denetleyici tarafından boşaltılana kadar bekler.

timeout_ms: Maksimum bekleme süresi.

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

Asenkron. Kanalın bağlantısını keser ve bağlantı kesme IRQ’sunu bekler.

timeout_ms: Maksimum bekleme süresi.

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

Asenkron. Kanalın iki taraftan biri tarafından bağlantısının kesilmesine kadar bekler.

timeout_ms: Maksimum bekleme süresi.

aioble — Asenkron BLE#

Örnekler#

Modül düzeyindeki fonksiyonlar#

Modül düzeyindeki sabitler#

İstisnalar#

Sınıflar#

`aioble` — Asenkron BLE#